Metacat

            String username, String[] groupnames,

            String sess_id) throws PropertyNotFoundException, HandlerException {

        if ( !PropertyService.getProperty("spatial.runSpatialOption").equals("true") ) {

            response.setContentType("text/html");

        } catch (java.lang.NullPointerException e) {

            // should be "default" but keep this for backwards compatibility

            // with knp site

            qformatArray[0] = "knp";

        }

        params.put("qformat", qformatArray);

     */

    public void handleLoginAction(PrintWriter out, Hashtable<String, String[]> params,

            HttpServletRequest request, HttpServletResponse response) {

        AuthSession sess = null;

        if(params.get("username") == null){

        }

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

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

        String qformat = "xml";

            HttpSession session = sess.getSessions();

            String id = session.getId();

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

                    + " into hash in login method");

            try {

            } catch (ServiceException se) {

                String errorMsg = "MetacatServlet.handleLoginAction - service problem registering session: "

                        + se.getMessage();

                out.println(errorMsg);

                se.printStackTrace(System.out);

                return;

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

                        out, null, null);

            } catch (Exception e) {               

                        + e.getMessage());

                e.printStackTrace(System.out);

            }

     */

    public void handleLogoutAction(PrintWriter out, Hashtable<String, String[]> params,

            HttpServletRequest request, HttpServletResponse response) {

        String qformat = "xml";

        if(params.get("qformat") != null){

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

        // close the connection

        HttpSession sess = request.getSession(false);

        if (sess != null) {

            + " will be invalidate in logout action");

                    + sess.getAttribute("username")

                    + " will be invalidate in logout action");

            sess.invalidate();

                        out, null, null);

            } catch (Exception e) {

                logMetacat.error(

                        + e.getMessage());

                e.printStackTrace(System.out);

            }

    protected void handleSQuery(Writer out, Hashtable<String, String[]> params,

            HttpServletResponse response, String user, String[] groups,

            String sessionid) throws PropertyNotFoundException {

        long squeryWarnLimit = Long.parseLong(PropertyService.getProperty("database.squeryTimeWarnLimit"));

        long startTime = System.currentTimeMillis();

        long runTime = outPutTime - startTime;

        if (runTime > squeryWarnLimit) {

                    " ms, squery: " + ((String[])params.get("query"))[0]);

        }

                " ran in " + runTime + " ms");

    }

    protected void handleQuery(Writer out, Hashtable<String, String[]> params,

            HttpServletResponse response, String user, String[] groups,

            String sessionid) throws PropertyNotFoundException, UnsupportedEncodingException, IOException {

        long queryWarnLimit = Long.parseLong(PropertyService.getProperty("database.queryTimeWarnLimit"));

        //create the query and run it

        long runTime = outPutTime -startTime;

        if (runTime > queryWarnLimit) {

                    " ms, squery: " + ((String[])params.get("query"))[0]);

        }

                " ran in " + runTime + " ms");

    }

    protected void handleExportAction(Hashtable<String, String[]> params,

            HttpServletResponse response,

            String user, String[] groups, String passWord) {

        // Output stream

        ServletOutputStream out = null;

        // Zip output stream

                    zOut.close();

                }

            } catch (IOException ioe) {

                        + ioe.getMessage());

                e.printStackTrace(System.out);

            }

                    + e.getMessage());

            e.printStackTrace(System.out);

    protected void handleReadInlineDataAction(Hashtable<String, String[]> params,

            HttpServletRequest request, HttpServletResponse response,

            String user, String passWord, String[] groups) {

        String[] docs = new String[10];

        String inlineDataId = null;

        String docId = "";

                    out.close();

                }

            } catch (IOException ioe) {

                        + ioe.getMessage());

                e.printStackTrace(System.out);

            }

                    + e.getMessage());

            e.printStackTrace(System.out);

        }

    public void handleReadAction(Hashtable<String, String[]> params, HttpServletRequest request,

            HttpServletResponse response, String user, String passWord,

            String[] groups) {

        ServletOutputStream out = null;

        ZipOutputStream zout = null;

        PrintWriter pw = null;

            // 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) {

                        + exc.getMessage());

                exc.printStackTrace(System.out);

                try {

                        zout.close();

                    }

                } catch (IOException ie) {

                            + ie.getMessage());

                    ie.printStackTrace(System.out);

                }

                }

            } catch (Exception e2) {

                e2.printStackTrace(System.out);

            }

                    + e.getMessage());

            e.printStackTrace(System.out);

        }

        params.put("permOrder", new String[] {permissionOrder});

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

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        PrintWriter out = new PrintWriter(baos);

        handleSetAccessAction(out, params, username, null, null);

          } catch (McdbException e) {

              // any exceptions in reading the xml from disc, and we go back to the

              // old way of creating the xml directly.

                "- could not read from document file " + 

                docid + ": " + e.getMessage());

              e.printStackTrace(System.out);

        out.println(this.SUCCESS);

        out.println("Document deleted.");

        out.println(this.SUCCESSCLOSE);

          "Document deleted.");

        try {

            //check the permission for read

            if (!DocumentImpl.hasReadPermission(user, groups, docid)) {

                        + " does not have permission"

                        + " to read the document with the docid " + docid);

                throw e;

                        ContentTypeProvider provider = new ContentTypeProvider(

                                docid);

                        contentType = provider.getContentType();

                                + contentType);

                    }

                    response.setContentType(contentType);

                    } catch (McdbException e) {

                        // any exceptions in reading the xml from disc, and we go back to the

                        // old way of creating the xml directly.

                        e.printStackTrace(System.out);

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

                    }

                    // detect actual encoding

                    String docString = doc.toString(user, groups, withInlineData);

        			String encoding = xsr.getEncoding();

                    Writer w = null;

        			if (encoding != null) {

                  out.println(msg);

                }

                return msg;

            }

        } catch (MetacatUtilException ue) {

            ue.printStackTrace(System.out);

            // TODO: This is a bug, as it allows one to bypass the access check -- need to throw an exception

        }

        try {

          // Get the document indicated

          String[] doctext = params.get("doctext");

          String pub = null;

              return msg;

          }

          StringReader xmlReader = new StringReader(doctext[0]);

          boolean validate = false;

          DocumentImplWrapper documentWrapper = null;

              // write the document to the database and disk

              String accNumber = docid[0];

                doAction + " " + accNumber + "...");

              if (accNumber == null || accNumber.equals("")) {

                  newdocid = documentWrapper.write(dbConn, doctext[0], pub, dtd,

                          doAction, null, user, groups);

                  EventLog.getInstance().log(ipAddress, user, "", action[0]);

              output += this.ERROR;

              output += npe.getMessage();

              output += this.ERRORCLOSE;

              npe.printStackTrace();

          }

        } catch (Exception e) {

            output += this.ERROR;

            output += e.getMessage();

            output += this.ERRORCLOSE;

            e.printStackTrace();

        }

                        out, null, null);

            } catch (Exception e) {

                e.printStackTrace(System.out);

            }

        }

     */

    private static boolean needDTDValidation(StringReader xmlreader)

    throws IOException {

        StringBuffer cbuff = new StringBuffer();

        java.util.Stack<String> st = new java.util.Stack<String>();

        boolean validate = false;

            }

        }

        return validate;

    }

      HttpServletRequest request, HttpServletResponse response,

      String user, String[] groups) {

      String[] docid = params.get("docid");

      if(docid == null){

        out.println(this.ERROR);

        out.println("Docid not specified.");

        out.println(this.ERRORCLOSE);

          "Docid not specified for the document to be deleted.");

      } else {

            //out.println("Error deleting document!!!");

            out.println(dnfe.getMessage());

            out.println(this.ERRORCLOSE);

              "Document could not be deleted: "

                    + dnfe.getMessage());

            dnfe.printStackTrace(System.out);

        try {

            // get a connection from the pool

            dbConn = DBConnectionPool

            serialNumber = dbConn.getCheckOutSerialNumber();

            DBValidate valobj = new DBValidate(dbConn);

//            boolean valid = valobj.validateString(valtext);

            Hashtable<String,String[]> params, HttpServletResponse response, String username,

            String[] groupnames) {

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

        if (docid.startsWith("urn:")) {

                String actualDocId = LSIDUtil.getDocId(docid, false);

                docid = actualDocId;

            } catch (ParseLSIDException ple) {

                ple.printStackTrace(System.out);

            }

        }

     * Handle "getdoctypes" action. Read all doctypes from db connection in XML

     * format

     */

        try {

            DBUtil dbutil = new DBUtil();

            String doctypes = dbutil.readDoctypes();

     * Handle the "getdtdschema" action. Read DTD or Schema file for a given

     * doctype from Metacat catalog system

     */

        String doctype = null;

        String[] doctypeArr = params.get("doctype");

     * @param params request parameters

     * @param response the http servlet response

     */

        String id = null;

        boolean exists = false;

        if(params.get("docid") != null) {

     * Handle the "getalldocids" action. return a list of all docids registered

     * in the system

     */

        String scope = null;

        if(params.get("scope") != null) {

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

     * Handle the "getlastdocid" action. Get the latest docid with rev number

     * from db connection in XML format

     */

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

        if (scope == null) {

     * @param request the http request object for getting request details

     * @param response the http response object for writing output

     */

        try {

        	// figure out the output as part of the action

            PrintWriter out = null;

                    endDate = new Timestamp((format.parse(end)).getTime());

                }

            } catch (ParseException e) {

                e.printStackTrace(System.out);

            }

	                        null, 

	                        null);

	            } catch (Exception e) {               

	                        + e.getMessage());

	                e.printStackTrace(System.out);

	            }

            }

        } catch (IOException e) {

            e.printStackTrace(System.out);

        } catch (MetacatUtilException ue) {

            ue.printStackTrace(System.out);

        }

    }

    protected void handleBuildIndexAction(Hashtable<String, String[]> params,

            HttpServletRequest request, HttpServletResponse response,

            String username, String[] groups) {

        // Get all of the parameters in the correct formats

        String[] docid = params.get("docid");

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

            out.close();

        } catch (IOException e) {

            e.printStackTrace(System.out);

        } catch (MetacatUtilException ue) {

            ue.printStackTrace(System.out);

        }

    }

     */

    protected void handleMultipartForm(HttpServletRequest request,

            HttpServletResponse response) {

        PrintWriter out = null;

        String action = null;

            sizeLimit = 

                (new Integer(PropertyService.getProperty("replication.datafilesizelimit"))).intValue();

        } catch (PropertyNotFoundException pnfe) {

            pnfe.printStackTrace(System.out);

        }

        try {

            MultipartParser mp = new MultipartParser(request,

                    fileList.put("filename", fileName);

                    fileList.put("name", fileTempLocation);

                } else {

                }

            }

        } catch (IOException ioe) {

            try {

                out = response.getWriter();

            } catch (IOException ioe2) {

            }

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

            out.println("<error>");

        try {

            out = response.getWriter();

        } catch (IOException ioe2) {

            ioe2.printStackTrace(System.out);

        }

            }

        } else if(action.equals("insertmultipart")) {

          if (username != null && !username.equals("public")) {

              handleInsertMultipartAction(request, response,

                            out, params, fileList, username, groupnames);

          } else {

            PrintWriter out, Hashtable<String,String[]> params, Hashtable<String,String> fileList,

            String username, String[] groupnames)

    {

      String action = null;

      String docid = null;

      String qformat = null;

      // Make sure we have a docid and datafile

      if (docid != null && fileList.containsKey("datafile")) 

      {

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

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

        String fileName = fileList.get("filename");

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

        if (fileName != null) 

        {

              {

                newFile = new File(newFileName);

                fileExists = newFile.exists();

                if(fileExists)

                {

                  newFile.delete();

                    } 

                    catch (IOException ioe) 

                    {

                        ioe.printStackTrace(System.out);

                    }

                    size = newFile.length();

                    if (size == 0) 

                    {

                    }

                }

                // Read the file with appropriate encoding

                XmlStreamReader xsr = new XmlStreamReader(new FileInputStream(newFile));

          }

          catch(Exception e)

          {

              e.printStackTrace(System.out);;

          }

        }

     * registering it in the Metacat db

     */

    private void handleUploadAction(HttpServletRequest request,

        //PrintWriter out = null;

        //Connection conn = null;

        //        String action = null;

        // Make sure we have a docid and datafile

        if (docid != null && fileList.containsKey("datafile")) {

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

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

            String fileName = fileList.get("filename");

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

            if (fileName != null) {

                        try {

                            newFile = new File(newFileName);

                            fileExists = newFile.exists();

                            if ( fileExists == false ) {

                                // copy file to desired output location

                                try {

                            } // Latent bug here if the file already exists, then the

                              // conditional fails but the document is still registered.

                              // maybe this never happens because we already requested a lock?

                            //register the file in the database (which generates

                            // an exception

                            //if the docid is not acceptable or other untoward

                                newFile.delete();

                            }

                            throw ee;

                        }

                        // not get force replication info from another metacat

                        ForceReplicationHandler frh = new ForceReplicationHandler(

                                docid, "insert", false, null);

                        // set content type and other response header fields

                        // first

                        out, null, null);

            } catch (Exception e) {

                        + e.getMessage());

                e.printStackTrace(System.out);

            }

        String[] accessBlock = params.get("accessBlock");

        if(accessBlock != null) {

            if (docList == null) {

                outputResponse(successList, errorList, out);

                return;

            }

                AccessControlForSingleFile accessControl = 

                    new AccessControlForSingleFile(docList[0]);

                accessControl.insertPermissions(accessBlock[0]);

            } catch(AccessControlException ace) {

            }

            outputResponse(successList, errorList, out);

            return;

        // Make sure the parameter is not null

        if (docList == null || principalList == null || permTypeList == null

                || permissionList == null) {

                    + "?action=setaccess&docid=pipeline.1.1&principal=public"

                    + "&permission=read&permType=allow&permOrder=allowFirst";

            errorList.addElement(error);

            packageSet = 

                MetacatUtil.getOptionList(PropertyService.getProperty("xml.packagedoctypeset"));

        } catch (PropertyNotFoundException pnfe) {

                    + pnfe.getMessage());

        }

        //debug

        if (packageSet != null) {

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

            }

        }

                    String actualDocId = LSIDUtil.getDocId(docid, false);

                    docid = actualDocId;

                } catch (ParseLSIDException ple) {

                            "could not parse lsid: " + docid + " : " + ple.getMessage()); 

                    ple.printStackTrace(System.out);

                }

                owner = getFieldValueForDoc(accessionNumber, "user_owner");

                publicId = getFieldValueForDoc(accessionNumber, "doctype");

            } catch (Exception e) {

                e.printStackTrace(System.out);

                errorList.addElement(error);

                continue;

            }

                    //insert permission

                    AccessControlForSingleFile accessControl = 

                        new AccessControlForSingleFile(accessionNumber);

                } catch (Exception ee) {

                    ee.printStackTrace(System.out);

                    error = "Failed to set access control for document "

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

            }

            ForceReplicationHandler frh = 

                new ForceReplicationHandler(accessionNumber, isXml, null);

        }

        if (errorList.isEmpty()) {

        }

        if (params.get("forwardto")  != null) {

            try {

        try {

            //check out DBConnection

            conn = DBConnectionPool

            serialNumber = conn.getCheckOutSerialNumber();

            pstmt = conn.prepareStatement("SELECT " + fieldName

                    + " FROM xml_documents " + "WHERE docid = ? ");

                        + accessionNumber);

            }

        } catch (Exception e) {

                    + e.getMessage());

            throw e;

        } finally {

     * @ returns the array of identifiers

     */

    private Vector<String> getDocumentList() throws SQLException {

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

        PreparedStatement pstmt = null;

        ResultSet rs = null;

        try {

            //check out DBConnection

            conn = DBConnectionPool

            serialNumber = conn.getCheckOutSerialNumber();

            pstmt = conn.prepareStatement("SELECT docid, rev"

                    + " FROM xml_documents ");

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

            }

        } catch (SQLException e) {

                    + e.getMessage());

            throw e;

        } finally {

                pstmt.close();

            } catch (SQLException se) {

                        + se.getMessage());

                throw se;

            } finally {

     * If the given docid only have one seperter, we need

     * append rev for it. The rev come from xml_documents

     */

        String newAccNum = null;

        String separator = PropertyService.getProperty("document.accNumSeparator");

        int firstIndex = docid.indexOf(separator);

                sitemapInterval = 

                    Integer.parseInt(PropertyService.getProperty("sitemap.interval"));

            } catch (PropertyNotFoundException pnfe) {

            }

            File directory = new File(directoryName);