Metacat

import com.oreilly.servlet.multipart.ParamPart;

import com.oreilly.servlet.multipart.Part;

import edu.ucsb.nceas.utilities.Options;

/**

    private static final String CONFIG_DIR = "WEB-INF";

    private static final String CONFIG_NAME = "metacat.properties";

    /**

     * Initialize the servlet by creating appropriate database connections

     */

            String dirPath = context.getRealPath(CONFIG_DIR);

            File propertyFile = new File(dirPath, CONFIG_NAME);

            Options options = null;

            try {

                options = Options.initialize(propertyFile);

            } catch (IOException ioe) {

            }

            util = new MetaCatUtil();

            // Index the paths specified in the metacat.properties

            checkIndexPaths();

                               + ") initialized.");

        } catch (ServletException ex) {

            throw ex;

        } catch (SQLException e) {

        }

    }

        if (MetaCatUtil.pathsForIndexing != null) {

            DBConnection conn = null;

            int serialNumber = -1;

            ResultSet rs = null;

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

                           + (String) MetaCatUtil.pathsForIndexing.elementAt(i)

                try {

                    //check out DBConnection

                    rs = pstmt.getResultSet();

                    if (!rs.next()) {

                        rs.close();

                        pstmt.close();

                        conn.increaseUsageCount(1);

                              "Inserting following path in xml_path_index: "

                              + (String)MetaCatUtil.pathsForIndexing

                        pstmt = conn.prepareStatement("SELECT DISTINCT n.docid, "

                              + "n.nodedata, n.nodedatanumerical, n.parentnodeid"

                        rs = pstmt.getResultSet();

                        int count = 0;

                                       "Executed the select statement for: "

                                       + (String) MetaCatUtil.pathsForIndexing

                        try {

                            while (rs.next()) {

                        pstmt.close();

                        conn.increaseUsageCount(1);

                                + " records from xml_nodes for '"

                                + (String) MetaCatUtil.pathsForIndexing.elementAt(i)

                    } else {

                    }

                    rs.close();

                    conn.increaseUsageCount(1);

                } catch (Exception e) {

                }finally {

                    //check in DBonnection

                    DBConnectionPool.returnDBConnection(conn, serialNumber);

            }

        }

    }

            util = new MetaCatUtil();

        }

        /*

         * +connPool.getSizeOfDBConnectionPool(),10);

         */

        //If all DBConnection in the pool are free and DBConnection pool

        //size is greater than initial value, shrink the connection pool

            }

            String action = ((String[]) params.get("action"))[0];

            // This block handles session management for the servlet

            // by looking up the current session information for all actions

                HttpSession sess = request.getSession(true);

                if (sess.isNew() && !params.containsKey("sessionid")) {

                    // session expired or has not been stored b/w user requests

                    username = "public";

                    sess.setAttribute("username", username);

                } else {

                    try {

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

                            sess_id = ((String[]) params.get("sessionid"))[0];

                            if (sessionHash.containsKey(sess_id)) {

                                sess = (HttpSession) sessionHash.get(sess_id);

                            }

                        } else {

                            // we already store the session in login, so we

                            // don't need here

                            /*

                             * parameter ", 40); sess_id =

                             * (String)sess.getId();

                             * + sess_id + " which has username " +

                             * sess.getAttribute("username") + " into session

                             * hash in handleGetOrPost method", 35);

                             */

                        }

                    } catch (IllegalStateException ise) {

                                + "happen: the session should be valid: "

                                + ise.getMessage());

                    }

                    username = (String) sess.getAttribute("username");

                    password = (String) sess.getAttribute("password");

                    groupnames = (String[]) sess.getAttribute("groupnames");

                }

                if (username == null || (username.trim().equals(""))) {

                    username = "public";

                }

            }

            // Now that we know the session is valid, we can delegate the

            // request

        }

        String un = ((String[]) params.get("username"))[0];

        String pw = ((String[]) params.get("password"))[0];

        String qformat = "xml";

        if (isValid) {

            HttpSession session = sess.getSessions();

            String id = session.getId();

                    + "which has username" + session.getAttribute("username")

            sessionHash.put(id, session);

        }

                        out, null);

            } catch (Exception e) {

                        "Error in MetaCatServlet.handleLoginAction: "

            }

        }

    }

        // close the connection

        HttpSession sess = request.getSession(false);

        if (sess != null) {

                    + sess.getAttribute("username")

            sess.invalidate();

        }

                        "-//NCEAS//login//EN", "-//W3C//HTML//EN", qformat,

                        out, null);

            } catch (Exception e) {

                        "Error in MetaCatServlet.handleLogoutAction"

            }

        }

    }

        DBQuery queryobj = new DBQuery(saxparser);

        queryobj.findDocuments(response, out, params, user, groups, sessionid);

        double outPutTime = System.currentTimeMillis() / 1000;

    }

        DBQuery queryobj = new DBQuery(saxparser);

        queryobj.findDocuments(response, out, params, user, groups, sessionid);

        double outPutTime = System.currentTimeMillis() / 1000;

        //handleSQuery(out, params, response,user, groups, sessionid);

    }

                    zOut.close();

                }

            } catch (IOException ioe) {

                        + "in MetacatServlet.handleExportAction: "

            }

                    "Error in MetacatServlet.handleExportAction: "

            e.printStackTrace(System.out);

        }

                    out.close();

                }

            } catch (IOException ioe) {

                        + "in MetacatServlet.handleExportAction: "

            }

                    "Error in MetacatServlet.handleReadInlineDataAction: "

        }

    }

                DBConnectionPool.returnDBConnection(conn, serialNumber);

            }

        }

        return nodeId;

    }

            // the docid which didn't be found

            String notFoundDocId = notFoundE.getUnfoundDocId();

            String notFoundRevision = notFoundE.getUnfoundRevision();

            try {

                // read docid from remote server

                readFromRemoteMetaCat(response, notFoundDocId,

                }

            } catch (Exception exc) {

                        "Erorr in MetacatServlet.hanldReadAction: "

                try {

                    if (out != null) {

                        response.setContentType("text/xml");

                        zout.close();

                    }

                } catch (IOException ie) {

                            + "in MetacatServlet.handleReadAction: "

                }

            }

        } catch (Exception e) {

                }

            } catch (IOException ioe) {

                        + "in MetacatServlet.handleReadAction: "

                ioe.printStackTrace(System.out);

            }

                    "Error in MetacatServlet.handleReadAction: "

            //e.printStackTrace(System.out);

        }

    }

                    ContentTypeProvider provider = new ContentTypeProvider(

                            docid);

                    contentType = provider.getContentType();

                }

                response.setContentType(contentType);

            out.println("<error>");

            out.println("Docid not specified");

            out.println("</error>");

            return;

        }

            out.println("<error>");

            out.println("User '" + user + "' not allowed to insert and update");

            out.println("</error>");

            return;

        }

                    // write the document to the database

                    try {

                        String accNumber = docid[0];

                        if (accNumber.equals("")) {

                            accNumber = null;

                        }

            }

        }

        return validate;

    }

    {

        boolean needSchemaValidate = false;

        if (xml == null) {

            return needSchemaValidate;

        }

        System.out.println("before get target line");

            needSchemaValidate = true;

        }

        return needSchemaValidate;

    }

        String eml2_1_0NameSpace = DocumentImpl.EML2_1_0NAMESPACE;

        if (xml == null) {

            return namespace;

        }

        String targetLine = getSchemaLine(xml);

                }

            }

            schemaLocation = targetLine.substring(start + 1, end);

            if (schemaLocation.indexOf(eml2_0_0NameSpace) != -1) {

                namespace = eml2_0_0NameSpace;

            } else if (schemaLocation.indexOf(eml2_0_1NameSpace) != -1) {

            }

        }

        return namespace;

            tmp = xml.read();

        }

        secondLine = buffer.toString();

        xml.reset();

        return secondLine;

    }

                    docid, event, startDate, endDate));

            out.close();

        } catch (IOException e) {

        }

    }

            out.println("</success>");

            out.close();

        } catch (IOException e) {

                    "Could not open http response for writing: "

        }

    }

        Hashtable fileList = new Hashtable();

        int sizeLimit = (new Integer(MetaCatUtil.getOption("datafilesizelimit")))

                .intValue();

        try {

            // MBJ: need to put filesize limit in Metacat config

            try {

                out = response.getWriter();

            } catch (IOException ioe2) {

            }

            out.println("<?xml version=\"1.0\"?>");

            out.println("<error>");

        try {

            out = response.getWriter();

        } catch (IOException ioe2) {

        }

        if (action.equals("upload")) {

            // Get a reference to the file part of the form

            FilePart filePart = (FilePart) fileList.get("datafile");

            String fileName = filePart.getFileName();

            // Check if the right file existed in the uploaded data

            if (fileName != null) {

                try {

                    // +"...", 10);

                    //If document get lock data file grant

                    if (DocumentImpl.getDataFileLockGrant(docid)) {

        //debug

        if (packageSet != null) {

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

            }

        }

                owner = getFieldValueForDoc(accessionNumber, "user_owner");

                publicId = getFieldValueForDoc(accessionNumber, "doctype");

            } catch (Exception e) {

                error = "Error in set access control for document - "

                        + accessionNumber + e.getMessage();

                errorList.addElement(error);

                            + accessionNumber + " successfully";

                    successList.addElement(success);

                } catch (Exception ee) {

                            "Erorr in handleSetAccessAction2: "

                    error = "Faild to set access control for document "

                            + accessionNumber + " because " + ee.getMessage();

                    errorList.addElement(error);

                        + accessionNumber);

            }

        } catch (Exception e) {

                    "Exception in MetacatServlet.getPublicIdForDoc: "

            throw e;

        } finally {

            try {

                docList.add(docid + "." + rev);

            }

        } catch (SQLException e) {

                    "Exception in MetacatServlet.getDocumentList: "

            throw e;

        } finally {

            try {

                pstmt.close();

            } catch (SQLException se) {

                    "Exception in MetacatServlet.getDocumentList: "

                throw se;

            } finally {

                DBConnectionPool.returnDBConnection(conn, serialNumber);

            // in other suituation we don't change the docid

            newAccNum = docid;

        }

        return newAccNum;

    }

}