Metacat

import java.util.Vector;

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

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

import org.apache.log4j.Logger;

import org.xml.sax.Attributes;

     * @param unaccessableNodePair the node pairs (start id and end id)

     *            which this user should not access

     */

        logMetacat.info("querySpecification.printExtendedSQL called\n");

        StringBuffer self = new StringBuffer();

        Vector elementVector = new Vector();

        	String path = (String)returnFieldList.elementAt(i);

        	// Since return fileds having preicates will be handle in another path,

        	// we should skip it.

        		continue;

        	}

        		attributeVector.add(path);

        		elementVector.add(path);

        	} 

        	try {

        }

        // check if has return field

}

  /**

  private void handleUpdateRequest(PrintWriter out, Hashtable<String, String[]> params,

                                    HttpServletResponse response)

  {

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

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

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

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.GeneralPropertyException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

        		"Service problem while intializing MetaCat Servlet: " + se.getMessage();

            logMetacat.error(errorMessage);

            throw new ServletException(errorMessage);

        	String errorMessage = 

        		"Utility problem while intializing MetaCat Servlet: " + ue.getMessage();

            logMetacat.error(errorMessage);

        try {  

        	pathsForIndexing = SystemUtil.getPathsForIndexing();

        }

        	pathsForIndexing = null;

            logMetacat.error("Could not find index paths.  Setting " 

            		+ "pathsForIndexing to null: " + ue.getMessage());

			String errorString = "Critical property not found: " + pnfe.getMessage();

			logMetacat.error(errorString);

			throw new ServletException(errorString);

			String errorString = "Utility error: " + ue.getMessage();

			logMetacat.error(errorString);

			throw new ServletException(errorString);

				logMetacat.error("User '" + user + "' not allowed to insert and update");

				return;

			}

			logMetacat.error("Could not determine if user could insert or update: "

					+ ue.getMessage());

		}

        } catch (IOException e) {

			logMetacat.error("Could not open http response for writing: "

					+ e.getMessage());

			logMetacat.error("Could not determine if user is administrator: "

					+ ue.getMessage());

		}

            logMetacat.error(

                    "Could not open http response for writing: "

                    + e.getMessage());

			logMetacat.error("Could not determine if user is administrator: "

					+ ue.getMessage());

		}

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

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

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

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

import edu.ucsb.nceas.utilities.StringUtil;

			documentDir = PropertyService.getProperty("application.documentfilepath");

			documentPath = documentDir + FileUtil.getFS() + docid + separator + rev;

				FileWriter fileWriter = new FileWriter(documentPath);

				toXmlFromDb(fileWriter, user, groups, true);

			}

								leafNodeId, currentName, docid, leafParentId, leafData,

								leafDataNumerical));

					}

					logMetacat.warn("Could not get index paths: " + ue.getMessage());

				}

						pathsFoundForIndexing.put(path, new PathIndexEntry(leafNodeId,

								path, docid, leafParentId, leafData, leafDataNumerical));

					}

					logMetacat.warn("Could not get index paths: " + ue.getMessage());

				}

            }

								leafNodeId, fullPath, docid, leafParentId, leafData,

								leafDataNumerical));

					}

					logMetacat.warn("Could not get index paths: " + ue.getMessage());

				}

            }

import org.apache.log4j.Logger;

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

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.GeneralPropertyException;

import edu.ucsb.nceas.utilities.MetaDataProperty;

import edu.ucsb.nceas.utilities.PropertiesMetaData;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

import edu.ucsb.nceas.utilities.SortedProperties;

/**

 * A suite of utility classes for the metadata configuration utility

	 * @return a boolean that is true if properties are not unconfigured and

	 *         false otherwise

	 */

		try {

			String propertiesConfigured = PropertyService.getProperty("configutil.propertiesConfigured");

			if (propertiesConfigured != null && !propertiesConfigured.equals(UNCONFIGURED)) {

			}			

			return false;

		} catch (PropertyNotFoundException pnfe) {

					+ pnfe.getMessage());

		}

	}

import org.apache.log4j.Logger;

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

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.GeneralPropertyException;

import edu.ucsb.nceas.utilities.MetaDataProperty;

	 * @return a boolean that is true if properties are not unconfigured and

	 *         false otherwise

	 */

		try {

			return !PropertyService.getProperty("configutil.skinsConfigured").equals(

					PropertyService.UNCONFIGURED);

		} catch (PropertyNotFoundException pnfe) {

					+ pnfe.getMessage());

		}

	}

	 * 

	 * @return a Vector of Strings holding the administrators

	 */

		if (administrators == null) {

			populateAdministrators();

		}

	 * 

	 * @return a Vector of Strings holding the submitters

	 */

		if (allowedSubmitters == null) {			

			populateAllowedSubmitters();	

		}

	 * 

	 * @return a Vector of Strings holding the denied submitters

	 */

		if (deniedSubmitters == null) {

			populateDeniedSubmitters();

		}

	 * 

	 * @return a Vector of Strings holding the moderators

	 */

		if (moderators == null) {

			populateModerators();

		}

	 * Get the vector of administrator credentials from metacat.properties

	 * and put into global administrators list

	 */

		String administratorString = null;

		try {

			administratorString = 

				PropertyService.getProperty("auth.administrators");

		} catch (PropertyNotFoundException pnfe) {

							+ "There will be no registered metacat adminstrators: "

							+ pnfe.getMessage());

		}

	 * Get the vector of allowed submitter credentials from metacat.properties

	 * and put into global allowedSubmitters list

	 */

		String allowedSubmitterString = null;

		try {

			allowedSubmitterString = PropertyService.getProperty("auth.allowedSubmitters");

		} catch (PropertyNotFoundException pnfe) {

					+ "Anyone will be allowed to submit: "

					+ pnfe.getMessage());

		}		

	 * Get the vector of denied submitter credentials from metacat.properties

	 * and put into global deniedSubmitters list

	 */

		String deniedSubmitterString = null;

		try {

			deniedSubmitterString = PropertyService.getProperty("auth.deniedSubmitters");

		} catch (PropertyNotFoundException pnfe) {

					+ pnfe.getMessage());

		}		

		deniedSubmitters = StringUtil.toVector(deniedSubmitterString, ':');		

	 * Get the vector of moderator credentials from metacat.properties

	 * and put into global administrators list

	 */

		String moderatorString = null;

		try {

			moderatorString = 

				PropertyService.getProperty("auth.moderators");

		} catch (PropertyNotFoundException pnfe) {

							+ "There will be no registered metacat moderators: "

							+ pnfe.getMessage());

		}

	 * 

	 * @param request the http request.

	 */

		AuthSession authSession = null;

		// make sure we have username and password.

		if (userName == null || password == null) {

		}

		// Create auth session

		try {

			authSession = new AuthSession();

		} catch (Exception e) {

					+ e.getMessage());

		}

		// authenticate user against ldap

		if(!authSession.authenticate(request, userName,password)) {

		}

		// if login was successful, add the session information to the

				(String[]) session.getAttribute("groupnames"),

				(String) session.getAttribute("password"));

		} catch (ServiceException se) {

		}

		return true;

	 * @param request the http request that holds the login session

	 * @return boolean that is true if the user is logged in, false otherwise

	 */

		SessionData sessionData = null;

		String sessionId = request.getSession().getId();

			}

		} catch (PropertyNotFoundException pnfe) {

					+ "of property error: " + pnfe.getMessage());

		} catch (NumberFormatException nfe) {

					+ "of number conversion error: " + nfe.getMessage());

		}

	 * @return boolean that is true if the user is logged in as admin, false

	 *         otherwise

	 */

		if (!isUserLoggedIn(request)) {

			return false;

		}

	 * @return String holding the ldap login string

	 */	

	public static String createLDAPString(String username, String organization,

		if (username == null || organization == null || dnList == null || dnList.size() == 0) {

		}

		String ldapString = "uid=" + username + ",o=" + organization;

	 * @return a boolean that is true if all sections are configured and false

	 *         otherwise

	 */

		String authConfiguredString = PropertyService.UNCONFIGURED;

		try {

			authConfiguredString = PropertyService.getProperty("configutil.authConfigured");

		} catch (PropertyNotFoundException pnfe) {

					+ pnfe.getMessage());

		}

		return !authConfiguredString.equals(PropertyService.UNCONFIGURED);

	 *            a list of the user's groups

	 */

	public static boolean isAdministrator(String username, String[] groups)

		return onAccessList(getAdministrators(), username, groups);

	}

	 * @param groups

	 *            a list of the user's groups

	 */

		return onAccessList(getModerators(), username, groups);

	}

	 *            a list of the user's groups

	 */

	public static boolean isAllowedSubmitter(String username, String[] groups)

		if (getAllowedSubmitters().size() == 0) {

			// no allowedSubmitters list specified -

			// hence everyone should be allowed

	 *            a list of the user's groups

	 */

	public static boolean isDeniedSubmitter(String username, String[] groups)

		return (onAccessList(getDeniedSubmitters(), username, groups));

	}

	 *            a list of the user's groups

	 */

	public static boolean canInsertOrUpdate(String username, String[] groups)

		return (isAllowedSubmitter(username, groups) && !isDeniedSubmitter(username,

				groups));

	}

	 *            the HttpClient we will use to post. This is passed in since it

	 *            may need to be used after login by other methods.

	 */

		try {

			String username = 

				PropertyService.getProperty("geoserver.username");

			// check to see if the success string is part of the result

			if(postResult.indexOf(loginSuccessString) == -1) {

				logMetacat.debug(postResult);

			}

		} catch (PropertyNotFoundException pnfe) {

					+ "default account: " + pnfe.getMessage());

		} catch (IOException ioe) {

					+ "default account: " + ioe.getMessage());

		} 

	}

	 *            the new password

	 */

	public static void changePassword(HttpClient httpClient, String username, String password) 

		try {	

			HashMap<String, String> paramMap = new HashMap<String, String>();

			// check to see if the success string is part of the result

			if(postResult.indexOf(passwordSuccessString) == -1) {

				logMetacat.debug(postResult);

			}

			// send a post to apply the password changes.  Unfortunately, there really

			RequestUtil.post(httpClient, applyPostURL, null);		

		} catch (PropertyNotFoundException pnfe) {

					+ "default account: " + pnfe.getMessage());

		} catch (IOException ioe) {

					+ "default account: " + ioe.getMessage());

		} 

	}

	 * 

	 * @return a boolean that is true if geoserver is configured or bypassed

	 */

		String geoserverConfiguredString = PropertyService.UNCONFIGURED;

		try {

			geoserverConfiguredString = PropertyService.getProperty("configutil.geoserverConfigured");

		} catch (PropertyNotFoundException pnfe) {

					+ pnfe.getMessage());

		}

		// geoserver is configured if not unconfigured

	 * @return a boolean that is true if database is not unconfigured and false

	 *         otherwise

	 */

		String databaseConfiguredString = PropertyService.UNCONFIGURED;

		try {

			databaseConfiguredString = 

				PropertyService.getProperty("configutil.databaseConfigured");

		} catch (PropertyNotFoundException pnfe) {

					+ pnfe.getMessage());

		}

		return !databaseConfiguredString.equals(PropertyService.UNCONFIGURED);

	 * 

	 * TODO MCD this should be retrieved from ldap instead of metacat.properties

	 */

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

		Vector<String> longOrgNames = null;

	 * 

	 * @return a Vector of Strings that hold all available organizations

	 */

		String orgBaseList = null;

		try {

			orgBaseList = PropertyService.getProperty("organization.base." + orgName);

		} catch (PropertyNotFoundException pnfe) {

					+ orgName + " : " + pnfe.getMessage());

		}

		// this will always return a vector (maybe an empty one)

	 * @return a boolean that is true if all sections are configured and false

	 *         otherwise

	 */

		String orgConfiguredString = PropertyService.UNCONFIGURED;

		try {

			orgConfiguredString = PropertyService.getProperty("configutil.organizationsConfigured");

		} catch (PropertyNotFoundException pnfe) {

					+ pnfe.getMessage());

		}

		return !orgConfiguredString.equals(PropertyService.UNCONFIGURED);

	 * @return a boolean that is true if skins are not unconfigured and false

	 *         otherwise

	 */

		try {

			return !PropertyService.getProperty("configutil.skinsConfigured").equals(

					PropertyService.UNCONFIGURED);

		} catch (PropertyNotFoundException pnfe) {

					+ pnfe.getMessage());

		}

	}

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

import edu.ucsb.nceas.utilities.StringUtil;

public class SystemUtil {

					return storedBackupDirLoc;

				}

			}

		} catch (ServiceException se) {

			logMetacat.warn("Could not get real application context: " + se.getMessage());

		}

			FileUtil.writeFile(storedBackupFileLoc, backupPath);

		} catch (IOException ioe) {

		} catch (ServiceException se) {

	}

	/**

			} catch (ServiceException se) {

				logMetacat.error("Could not get real application directory while trying to write "

							+ "stored backup directory: "+ storedBackupLocFile + " : " + se.getMessage());

			}

		} else {

			logMetacat.warn("Could not write out stored backup directory." 

	/**

	 * Get a list of xml paths that need to be indexed

	 */

		Vector <String> indexPaths = null;

		try {

			indexPaths = 

				StringUtil.toVector(PropertyService.getProperty("xml.indexPaths"), ',');

		} catch (PropertyNotFoundException pnfe) {

		}

		return indexPaths;

import edu.ucsb.nceas.utilities.GeneralPropertyException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

import edu.ucsb.nceas.utilities.FileUtil;

/**

 * A suite of utility classes for the metadata catalog server

					&& DatabaseUtil.isDatabaseConfigured()

					&& GeoserverUtil.isGeoserverConfigured()

					&& isBackupDirConfigured();

			logMetacat.error("Could not determine if metacat is configured due to utility exception: "

					+ ue.getMessage());

		} catch (PropertyNotFoundException pnfe) {

	 * @return false if the application.backupDir property does not point to a

	 *         writable directory.

	 */

		String backupDir = PropertyService.getProperty("application.backupDir");

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

			return false;

	 * @return a boolean that is false if dev.runConfiguration is false and the

	 *         backup properties file exists.

	 */

		try {

			// If the system is not configured to do bypass, return false.

			if (!PropertyService.doBypass()) {

			return true;

		} catch (GeneralPropertyException gpe) {

					+ gpe.getMessage());

		}

	}

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

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

/**

 * A Class that implements session tracking for MetaCatServlet users.

				if (AuthUtil.isAdministrator(username, groups)) {

					out.append("\n  <isAdministrator></isAdministrator>\n");

				}

				logMetacat.error("Could not determine if user is administrator. "

						+ "Omitting from xml output: " + ue.getMessage());

			}

				if (AuthUtil.isModerator(username, groups)) {

					out.append("\n  <isModerator></isModerator>\n");

				}

				logMetacat.error("Could not determine if user is moderator. "

						+ "Omitting from xml output: " + ue.getMessage());

			}

import edu.ucsb.nceas.dbadapter.*;

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

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

import java.io.*;

import java.util.Hashtable;

					queryTermsInPathIndex.add(newTerm);

					return;

				}    		

				logMetacat.warn("Could not get index paths: " + ue.getMessage());

			}

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

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

/** a utility class that represents a single term in a query */

public class QueryTerm

				if (SystemUtil.getPathsForIndexing().contains(pathexpr)) {

					usePathIndex = true;

				}

				log.warn("Could not get index paths: " + ue.getMessage());

			}

        }

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

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

/**

 * Control the display of the login page 

				if (validationErrors.size() == 0) {

					try {

						isLoggedIn = AuthUtil.logUserIn(request, userName, password);

						String errorMessage = "Could not log in as: " + userName

						+ " : " + ue.getMessage() + ". Please try again";

						processingErrors.add(errorMessage);

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

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

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

import edu.ucsb.nceas.utilities.GeneralPropertyException;

/**

					PropertyService.persistMainBackupProperties(request.getSession()

							.getServletContext());

				}

				String errorMessage = "Error updating geoserver password: " + ue.getMessage();

				logMetacat.error(errorMessage);

				processingErrors.add(errorMessage);

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

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

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

import edu.ucsb.nceas.utilities.GeneralPropertyException;

/**

				"Admin problem while handling request: " + ae.getMessage();

			logMetacat.error(errorMessage);

			processingErrors.add(errorMessage);

			String errorMessage = 

				"Utility problem while handling request: " + ue.getMessage();

			logMetacat.error(errorMessage);

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

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

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

import edu.ucsb.nceas.utilities.FileUtil;

import edu.ucsb.nceas.utilities.GeneralPropertyException;

/**

 * Control the display of the login page 

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

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

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

import edu.ucsb.nceas.utilities.DBUtil;

import edu.ucsb.nceas.utilities.FileUtil;

				throw new AdminException("An attempt was made to get the database version "

								+ "before system properties were configured");

			}

			throw new AdminException("Could not determine the database version: "

					+ ue.getMessage());

		}