/**

 * The contents of this file are subject to the OpenMRS Public License

 * Version 1.0 (the "License"); you may not use this file except in

 * compliance with the License. You may obtain a copy of the License at

 * http://license.openmrs.org

 *

 * Software distributed under the License is distributed on an "AS IS"

 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the

 * License for the specific language governing rights and limitations

 * under the License.

 *

 * Copyright (C) OpenMRS, LLC.  All Rights Reserved.

 */

package org.openmrs.api.impl;



import java.io.StringWriter;

import java.io.UnsupportedEncodingException;

import java.net.InetAddress;

import java.net.UnknownHostException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Properties;

import java.util.Set;

import java.util.SortedMap;

import java.util.TreeMap;



import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.openmrs.Concept;

import org.openmrs.ConceptClass;

import org.openmrs.ConceptDatatype;

import org.openmrs.ConceptProposal;

import org.openmrs.ConceptSource;

import org.openmrs.EncounterType;

import org.openmrs.FieldType;

import org.openmrs.GlobalProperty;

import org.openmrs.ImplementationId;

import org.openmrs.Location;

import org.openmrs.MimeType;

import org.openmrs.OpenmrsObject;

import org.openmrs.PatientIdentifierType;

import org.openmrs.Privilege;

import org.openmrs.Role;

import org.openmrs.Tribe;

import org.openmrs.User;

import org.openmrs.api.APIAuthenticationException;

import org.openmrs.api.APIException;

import org.openmrs.api.AdministrationService;

import org.openmrs.api.EventListeners;

import org.openmrs.api.GlobalPropertyListener;

import org.openmrs.api.context.Context;

import org.openmrs.api.db.AdministrationDAO;

import org.openmrs.module.Module;

import org.openmrs.module.ModuleFactory;

import org.openmrs.module.ModuleUtil;

import org.openmrs.reporting.AbstractReportObject;

import org.openmrs.reporting.Report;

import org.openmrs.util.LocaleUtility;

import org.openmrs.util.OpenmrsConstants;

import org.openmrs.util.OpenmrsUtil;

import org.openmrs.util.PrivilegeConstants;

import org.springframework.util.StringUtils;



/**

 * Default implementation of the administration services. This class should not be used on its own.

 * The current OpenMRS implementation should be fetched from the Context

 * 

 * @see org.openmrs.api.AdministrationService

 * @see org.openmrs.api.context.Context

 */

public class AdministrationServiceImpl extends BaseOpenmrsService implements AdministrationService, GlobalPropertyListener {

	

	protected Log log = LogFactory.getLog(getClass());

	

	protected AdministrationDAO dao;

	

	private EventListeners eventListeners;

	

	/**

	 * An always up-to-date collection of the allowed locales.

	 */

	private GlobalLocaleList globalLocaleList;

	

	/**

	 * Default empty constructor

	 */

	public AdministrationServiceImpl() {

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#setAdministrationDAO(org.openmrs.api.db.AdministrationDAO)

	 */

	public void setAdministrationDAO(AdministrationDAO dao) {

		this.dao = dao;

	}

	

	public void setEventListeners(EventListeners eventListeners) {

		this.eventListeners = eventListeners;

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#createEncounterType(org.openmrs.EncounterType)

	 * @deprecated

	 */

	@Deprecated

	public void createEncounterType(EncounterType encounterType) throws APIException {

		Context.getEncounterService().saveEncounterType(encounterType);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#updateEncounterType(org.openmrs.EncounterType)

	 * @deprecated

	 */

	@Deprecated

	public void updateEncounterType(EncounterType encounterType) throws APIException {

		Context.getEncounterService().saveEncounterType(encounterType);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#deleteEncounterType(org.openmrs.EncounterType)

	 * @deprecated

	 */

	@Deprecated

	public void deleteEncounterType(EncounterType encounterType) throws APIException {

		Context.getEncounterService().purgeEncounterType(encounterType);

	}

	

	/**

	 * @see org.openmrs.api.PatientService#savePatientIdentifierType(PatientIdentifierType)

	 * @deprecated replaced by

	 *             {@link org.openmrs.api.PatientService#savePatientIdentifierType(PatientIdentifierType)}

	 */

	@Deprecated

	public void createPatientIdentifierType(PatientIdentifierType patientIdentifierType) throws APIException {

		Context.getPatientService().savePatientIdentifierType(patientIdentifierType);

	}

	

	/**

	 * @see org.openmrs.api.PatientService#savePatientIdentifierType(PatientIdentifierType)

	 * @deprecated replaced by

	 *             {@link org.openmrs.api.PatientService#savePatientIdentifierType(PatientIdentifierType)}

	 */

	@Deprecated

	public void updatePatientIdentifierType(PatientIdentifierType patientIdentifierType) throws APIException {

		Context.getPatientService().savePatientIdentifierType(patientIdentifierType);

	}

	

	/**

	 * @see org.openmrs.api.PatientService#purgePatientIdentifierType(PatientIdentifierType)

	 * @deprecated replaced by

	 *             {@link org.openmrs.api.PatientService#purgePatientIdentifierType(PatientIdentifierType)}

	 */

	@Deprecated

	public void deletePatientIdentifierType(PatientIdentifierType patientIdentifierType) throws APIException {

		Context.getPatientService().purgePatientIdentifierType(patientIdentifierType);

	}

	

	/**

	 * Create a new Tribe

	 * 

	 * @param tribe Tribe to create

	 * @throws APIException

	 * @deprecated

	 */

	@Deprecated

	public void createTribe(Tribe tribe) throws APIException {

		throw new APIException("The Tribe object is no longer supported.  Install the Tribe module");

	}

	

	/**

	 * Update Tribe

	 * 

	 * @param tribe Tribe to update

	 * @throws APIException

	 * @deprecated

	 */

	@Deprecated

	public void updateTribe(Tribe tribe) throws APIException {

		throw new APIException("The Tribe object is no longer supported.  Install the Tribe module");

	}

	

	/**

	 * Delete Tribe

	 * 

	 * @param tribe Tribe to delete

	 * @throws APIException

	 * @deprecated

	 */

	@Deprecated

	public void deleteTribe(Tribe tribe) throws APIException {

		throw new APIException("The Tribe object is no longer supported.  Install the Tribe module");

	}

	

	/**

	 * Retire Tribe

	 * 

	 * @param tribe Tribe to retire

	 * @throws APIException

	 * @deprecated

	 */

	@Deprecated

	public void retireTribe(Tribe tribe) throws APIException {

		throw new APIException("The Tribe object is no longer supported.  Install the Tribe module");

	}

	

	/**

	 * Unretire Tribe

	 * 

	 * @param tribe Tribe to unretire

	 * @throws APIException

	 * @deprecated

	 */

	@Deprecated

	public void unretireTribe(Tribe tribe) throws APIException {

		throw new APIException("The Tribe object is no longer supported.  Install the Tribe module");

	}

	

	/**

	 * @deprecated

	 */

	@Deprecated

	public void createFieldType(FieldType fieldType) throws APIException {

		Context.getFormService().saveFieldType(fieldType);

	}

	

	/**

	 * @deprecated

	 */

	@Deprecated

	public void updateFieldType(FieldType fieldType) throws APIException {

		Context.getFormService().saveFieldType(fieldType);

	}

	

	/**

	 * @deprecated

	 */

	@Deprecated

	public void deleteFieldType(FieldType fieldType) throws APIException {

		Context.getFormService().purgeFieldType(fieldType);

	}

	

	/**

	 * @deprecated use {@link org.openmrs.api.ObsService#saveMimeType(MimeType)}

	 */

	@Deprecated

	public void createMimeType(MimeType mimeType) throws APIException {

		Context.getObsService().saveMimeType(mimeType);

	}

	

	/**

	 * @deprecated use {@link org.openmrs.api.ObsService#saveMimeType(MimeType)}

	 */

	@Deprecated

	public void updateMimeType(MimeType mimeType) throws APIException {

		Context.getObsService().saveMimeType(mimeType);

	}

	

	/**

	 * @deprecated use {@link org.openmrs.api.ObsService#purgeMimeType(MimeType)}

	 */

	@Deprecated

	public void deleteMimeType(MimeType mimeType) throws APIException {

		Context.getObsService().purgeMimeType(mimeType);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#createLocation(org.openmrs.Location)

	 * @deprecated

	 */

	@Deprecated

	public void createLocation(Location location) throws APIException {

		Context.getLocationService().saveLocation(location);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#updateLocation(org.openmrs.Location)

	 * @deprecated

	 */

	@Deprecated

	public void updateLocation(Location location) throws APIException {

		Context.getLocationService().saveLocation(location);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#deleteLocation(org.openmrs.Location)

	 * @deprecated

	 */

	@Deprecated

	public void deleteLocation(Location location) throws APIException {

		Context.getLocationService().purgeLocation(location);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#createRole(org.openmrs.Role)

	 * @deprecated

	 */

	@Deprecated

	public void createRole(Role role) throws APIException {

		Context.getUserService().saveRole(role);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#updateRole(org.openmrs.Role)

	 * @deprecated

	 */

	@Deprecated

	public void updateRole(Role role) throws APIException {

		Context.getUserService().saveRole(role);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#deleteRole(org.openmrs.Role)

	 * @deprecated

	 */

	@Deprecated

	public void deleteRole(Role role) throws APIException {

		Context.getUserService().purgeRole(role);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#createPrivilege(org.openmrs.Privilege)

	 * @deprecated

	 */

	@Deprecated

	public void createPrivilege(Privilege privilege) throws APIException {

		Context.getUserService().savePrivilege(privilege);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#updatePrivilege(org.openmrs.Privilege)

	 * @deprecated

	 */

	@Deprecated

	public void updatePrivilege(Privilege privilege) throws APIException {

		Context.getUserService().savePrivilege(privilege);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#deletePrivilege(org.openmrs.Privilege)

	 * @deprecated

	 */

	@Deprecated

	public void deletePrivilege(Privilege privilege) throws APIException {

		Context.getUserService().purgePrivilege(privilege);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void createConceptClass(ConceptClass cc) throws APIException {

		Context.getConceptService().saveConceptClass(cc);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void updateConceptClass(ConceptClass cc) throws APIException {

		Context.getConceptService().saveConceptClass(cc);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void deleteConceptClass(ConceptClass cc) throws APIException {

		Context.getConceptService().purgeConceptClass(cc);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void createConceptDatatype(ConceptDatatype cd) throws APIException {

		Context.getConceptService().saveConceptDatatype(cd);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void updateConceptDatatype(ConceptDatatype cd) throws APIException {

		Context.getConceptService().saveConceptDatatype(cd);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void deleteConceptDatatype(ConceptDatatype cd) throws APIException {

		Context.getConceptService().purgeConceptDatatype(cd);

	}

	

	/**

	 * Create a new Report

	 * 

	 * @param report Report to create

	 * @deprecated see reportingcompatibility module

	 * @throws APIException

	 */

	@Deprecated

	public void createReport(Report report) throws APIException {

		if (!Context.hasPrivilege(OpenmrsConstants.PRIV_ADD_REPORTS))

			throw new APIAuthenticationException("Privilege required: " + OpenmrsConstants.PRIV_ADD_REPORTS);

		

		dao.createReport(report);

	}

	

	/**

	 * Update Report

	 * 

	 * @param report Report to update

	 * @deprecated see reportingcompatibility module

	 * @throws APIException

	 */

	@Deprecated

	public void updateReport(Report report) throws APIException {

		if (!Context.hasPrivilege(OpenmrsConstants.PRIV_EDIT_REPORTS))

			throw new APIAuthenticationException("Privilege required: " + OpenmrsConstants.PRIV_EDIT_REPORTS);

		

		dao.updateReport(report);

	}

	

	/**

	 * Delete Report

	 * 

	 * @param report Report to delete

	 * @deprecated see reportingcompatibility module

	 * @throws APIException

	 */

	@Deprecated

	public void deleteReport(Report report) throws APIException {

		if (!Context.hasPrivilege(OpenmrsConstants.PRIV_DELETE_REPORTS))

			throw new APIAuthenticationException("Privilege required: " + OpenmrsConstants.PRIV_DELETE_REPORTS);

		

		dao.deleteReport(report);

	}

	

	/**

	 * Create a new Report Object

	 * 

	 * @param reportObject Report Object to create

	 * @deprecated see reportingcompatibility module

	 * @throws APIException

	 */

	@Deprecated

	public void createReportObject(AbstractReportObject reportObject) throws APIException {

		if (!Context.hasPrivilege(OpenmrsConstants.PRIV_ADD_REPORT_OBJECTS))

			throw new APIAuthenticationException("Privilege required: " + OpenmrsConstants.PRIV_ADD_REPORT_OBJECTS);

		

		dao.createReportObject(reportObject);

	}

	

	/**

	 * Update Report Object

	 * 

	 * @param reportObject Report Object to update

	 * @deprecated see reportingcompatibility module

	 * @throws APIException

	 */

	@Deprecated

	public void updateReportObject(AbstractReportObject reportObject) throws APIException {

		if (!Context.hasPrivilege(OpenmrsConstants.PRIV_EDIT_REPORT_OBJECTS))

			throw new APIAuthenticationException("Privilege required: " + OpenmrsConstants.PRIV_EDIT_REPORT_OBJECTS);

		

		dao.updateReportObject(reportObject);

	}

	

	/**

	 * Delete Report Object

	 * 

	 * @param reportObjectId Internal Integer identifier of Report Object to delete

	 * @deprecated see reportingcompatibility module

	 * @throws APIException

	 */

	@Deprecated

	public void deleteReportObject(Integer reportObjectId) throws APIException {

		if (!Context.hasPrivilege(OpenmrsConstants.PRIV_DELETE_REPORT_OBJECTS))

			throw new APIAuthenticationException("Privilege required: " + OpenmrsConstants.PRIV_DELETE_REPORT_OBJECTS);

		

		dao.deleteReportObject(reportObjectId);

	}

	

	/**

	 * @deprecated moved to ConceptServiceImpl

	 */

	@Deprecated

	public void updateConceptWord(Concept concept) throws APIException {

		Context.getConceptService().updateConceptWord(concept);

	}

	

	/**

	 * @deprecated moved to ConceptServiceImpl

	 */

	@Deprecated

	public void updateConceptWords() throws APIException {

		Context.getConceptService().updateConceptWords();

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void updateConceptWords(Integer conceptIdStart, Integer conceptIdEnd) throws APIException {

		Context.getConceptService().updateConceptWords(conceptIdStart, conceptIdEnd);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void updateConceptSetDerived(Concept concept) throws APIException {

		Context.getConceptService().updateConceptSetDerived(concept);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void updateConceptSetDerived() throws APIException {

		Context.getConceptService().updateConceptSetDerived();

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void createConceptProposal(ConceptProposal cp) throws APIException {

		Context.getConceptService().saveConceptProposal(cp);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void updateConceptProposal(ConceptProposal cp) throws APIException {

		Context.getConceptService().saveConceptProposal(cp);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 */

	@Deprecated

	public void mapConceptProposalToConcept(ConceptProposal cp, Concept mappedConcept) throws APIException {

		Context.getConceptService().mapConceptProposalToConcept(cp, mappedConcept);

	}

	

	/**

	 * @deprecated moved to ConceptService

	 * @see org.openmrs.api.AdministrationService#rejectConceptProposal(org.openmrs.ConceptProposal)

	 */

	@Deprecated

	public void rejectConceptProposal(ConceptProposal cp) {

		Context.getConceptService().rejectConceptProposal(cp);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#mrnGeneratorLog(java.lang.String,

	 *      java.lang.Integer, java.lang.Integer)

	 * @deprecated

	 */

	@Deprecated

	public void mrnGeneratorLog(String site, Integer start, Integer count) throws APIException {

		if (!Context.hasPrivilege(PrivilegeConstants.EDIT_PATIENTS))

			throw new APIAuthenticationException("Privilege required: " + PrivilegeConstants.EDIT_PATIENTS);

		

		dao.mrnGeneratorLog(site, start, count);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getMRNGeneratorLog()

	 * @deprecated

	 */

	@Deprecated

	public Collection<?> getMRNGeneratorLog() throws APIException {

		if (!Context.hasPrivilege(PrivilegeConstants.EDIT_PATIENTS))

			throw new APIAuthenticationException("Privilege required: " + PrivilegeConstants.EDIT_PATIENTS);

		

		return dao.getMRNGeneratorLog();

	}

	

	/**

	 * Static-ish variable used to cache the system variables. This is not static so that every time

	 * a module is loaded or removed the variable is destroyed (along with the administration

	 * service) and recreated the next time it is called

	 */

	protected SortedMap<String, String> systemVariables = null;

	

	/**

	 * Set of locales which can be used to present messages in the user interface. Created lazily as

	 * needed by {@link #getAllowedLocales()}.

	 */

	private HashSet<Locale> presentationLocales;

	

	/**

	 * @see org.openmrs.api.AdministrationService#getSystemVariables()

	 */

	public SortedMap<String, String> getSystemVariables() throws APIException {

		if (systemVariables == null) {

			systemVariables = new TreeMap<String, String>();

			

			// Added the server's fully qualified domain name

			try {

				systemVariables.put("OPENMRS_HOSTNAME", InetAddress.getLocalHost().getCanonicalHostName());

			}

			catch (UnknownHostException e) {

				systemVariables.put("OPENMRS_HOSTNAME", "Unknown host: " + e.getMessage());

			}

			

			systemVariables.put("OPENMRS_VERSION", String.valueOf(OpenmrsConstants.OPENMRS_VERSION));

			systemVariables.put("DATABASE_NAME", OpenmrsConstants.DATABASE_NAME);

			systemVariables.put("DATABASE_BUSINESS_NAME", OpenmrsConstants.DATABASE_BUSINESS_NAME);

			systemVariables.put("OBSCURE_PATIENTS", String.valueOf(OpenmrsConstants.OBSCURE_PATIENTS));

			systemVariables.put("OBSCURE_PATIENTS_FAMILY_NAME", OpenmrsConstants.OBSCURE_PATIENTS_FAMILY_NAME);

			systemVariables.put("OBSCURE_PATIENTS_GIVEN_NAME", OpenmrsConstants.OBSCURE_PATIENTS_GIVEN_NAME);

			systemVariables.put("OBSCURE_PATIENTS_MIDDLE_NAME", OpenmrsConstants.OBSCURE_PATIENTS_MIDDLE_NAME);

			systemVariables.put("MODULE_REPOSITORY_PATH", ModuleUtil.getModuleRepository().getAbsolutePath());

			systemVariables.put("OPERATING_SYSTEM_KEY", String.valueOf(OpenmrsConstants.OPERATING_SYSTEM_KEY));

			systemVariables.put("OPERATING_SYSTEM", String.valueOf(OpenmrsConstants.OPERATING_SYSTEM));

		}

		

		return systemVariables;

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getGlobalProperty(java.lang.String)

	 */

	public String getGlobalProperty(String propertyName) throws APIException {

		// This method should not have any authorization check

		if (propertyName == null)

			return null;

		

		return dao.getGlobalProperty(propertyName);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getGlobalProperty(java.lang.String,

	 *      java.lang.String)

	 */

	public String getGlobalProperty(String propertyName, String defaultValue) throws APIException {

		String s = getGlobalProperty(propertyName);

		if (s == null)

			return defaultValue;

		return s;

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getGlobalPropertyObject(java.lang.String)

	 */

	public GlobalProperty getGlobalPropertyObject(String propertyName) {

		return dao.getGlobalPropertyObject(propertyName);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getGlobalProperties()

	 * @deprecated

	 */

	@Deprecated

	public List<GlobalProperty> getGlobalProperties() throws APIException {

		return getAllGlobalProperties();

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#setGlobalProperties(java.util.List)

	 * @deprecated

	 */

	@Deprecated

	public void setGlobalProperties(List<GlobalProperty> props) throws APIException {

		Context.getAdministrationService().saveGlobalProperties(props);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#deleteGlobalProperty(java.lang.String)

	 * @deprecated

	 */

	@Deprecated

	public void deleteGlobalProperty(String propertyName) throws APIException {

		purgeGlobalProperty(new GlobalProperty(propertyName));

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#setGlobalProperty(java.lang.String,

	 *      java.lang.String)

	 * @deprecated

	 */

	@Deprecated

	public void setGlobalProperty(String propertyName, String propertyValue) throws APIException {

		Context.getAdministrationService().saveGlobalProperty(new GlobalProperty(propertyName, propertyValue));

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#setGlobalProperty(org.openmrs.GlobalProperty)

	 * @deprecated

	 */

	@Deprecated

	public void setGlobalProperty(GlobalProperty gp) throws APIException {

		Context.getAdministrationService().saveGlobalProperty(gp);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#addGlobalProperty(org.openmrs.GlobalProperty)

	 * @deprecated

	 */

	@Deprecated

	public void addGlobalProperty(GlobalProperty gp) {

		setGlobalProperty(gp);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#addGlobalProperty(java.lang.String,

	 *      java.lang.String)

	 * @deprecated

	 */

	@Deprecated

	public void addGlobalProperty(String propertyName, String propertyValue) throws APIException {

		//dao.addGlobalProperty(propertyName, propertyValue);

		Context.getAdministrationService().saveGlobalProperty(new GlobalProperty(propertyName, propertyValue));

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getAllGlobalProperties()

	 */

	public List<GlobalProperty> getAllGlobalProperties() throws APIException {

		return dao.getAllGlobalProperties();

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getGlobalPropertiesByPrefix(java.lang.String)

	 */

	public List<GlobalProperty> getGlobalPropertiesByPrefix(String prefix) {

		return dao.getGlobalPropertiesByPrefix(prefix);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getGlobalPropertiesBySuffix(java.lang.String)

	 */

	public List<GlobalProperty> getGlobalPropertiesBySuffix(String suffix) {

		return dao.getGlobalPropertiesBySuffix(suffix);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#purgeGlobalProperty(org.openmrs.GlobalProperty)

	 */

	public void purgeGlobalProperty(GlobalProperty globalProperty) throws APIException {

		notifyGlobalPropertyDelete(globalProperty.getProperty());

		dao.deleteGlobalProperty(globalProperty);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#saveGlobalProperties(java.util.List)

	 */

	public List<GlobalProperty> saveGlobalProperties(List<GlobalProperty> props) throws APIException {

		log.debug("saving a list of global properties");

		

		// add all of the new properties

		for (GlobalProperty prop : props) {

			if (prop.getProperty() != null && prop.getProperty().length() > 0) {

				saveGlobalProperty(prop);

			}

		}

		

		return props;

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#saveGlobalProperty(org.openmrs.GlobalProperty)

	 */

	public GlobalProperty saveGlobalProperty(GlobalProperty gp) throws APIException {

		

		// only try to save it if the global property has a key

		if (gp.getProperty() != null && gp.getProperty().length() > 0) {

			dao.saveGlobalProperty(gp);

			notifyGlobalPropertyChange(gp);

			return gp;

		}

		

		return gp;

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#executeSQL(java.lang.String, boolean)

	 */

	public List<List<Object>> executeSQL(String sql, boolean selectOnly) throws APIException {

		if (sql == null || sql.trim().equals(""))

			return null;

		

		return dao.executeSQL(sql, selectOnly);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#addGlobalPropertyListener(GlobalPropertyListener)

	 */

	public void addGlobalPropertyListener(GlobalPropertyListener listener) {

		eventListeners.getGlobalPropertyListeners().add(listener);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#removeGlobalPropertyListener(GlobalPropertyListener)

	 */

	public void removeGlobalPropertyListener(GlobalPropertyListener listener) {

		eventListeners.getGlobalPropertyListeners().remove(listener);

	}

	

	/**

	 * Calls global property listeners registered for this create/change

	 * 

	 * @param gp

	 */

	private void notifyGlobalPropertyChange(GlobalProperty gp) {

		for (GlobalPropertyListener listener : eventListeners.getGlobalPropertyListeners())

			if (listener.supportsPropertyName(gp.getProperty()))

				listener.globalPropertyChanged(gp);

	}

	

	/**

	 * Calls global property listeners registered for this delete

	 * 

	 * @param propertyName

	 */

	private void notifyGlobalPropertyDelete(String propertyName) {

		for (GlobalPropertyListener listener : eventListeners.getGlobalPropertyListeners())

			if (listener.supportsPropertyName(propertyName))

				listener.globalPropertyDeleted(propertyName);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getImplementationId()

	 */

	public ImplementationId getImplementationId() throws APIException {

		String property = getGlobalProperty(OpenmrsConstants.GLOBAL_PROPERTY_IMPLEMENTATION_ID);

		

		// fail early if no gp has been defined yet

		if (property == null)

			return null;

		

		try {

			ImplementationId implId = OpenmrsUtil.getSerializer().read(ImplementationId.class, property);

			

			return implId;

		}

		catch (Throwable t) {

			log.debug("Error while getting implementation id", t);

		}

		

		return null;

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#setImplementationId(org.openmrs.ImplementationId)

	 */

	public void setImplementationId(ImplementationId implementationId) throws APIException {

		

		if (implementationId == null)

			return;

		

		// check the validity of this implementation id with the server

		String description = implementationId.getDescription();

		try {

			// check that source id is valid

			description = checkImplementationIdValidity(implementationId.getImplementationId(), description,

			    implementationId.getPassphrase());

			

			// save the server's description back to this concept source object

			implementationId.setDescription(description);

			

			boolean foundMatchingSource = false;

			// loop over the concept sources to make sure one exists for this hl7Code/implementationId

			List<ConceptSource> sources = Context.getConceptService().getAllConceptSources();

			if (sources != null) {

				for (ConceptSource source : sources) {

					if (implementationId.getImplementationId().equals(source.getHl7Code())) {

						foundMatchingSource = true;

					}

				}

			}

			

			// if no ConceptSource currently exists with this implementationId, save this implId

			// as a new ConceptSource

			if (!foundMatchingSource) {

				ConceptSource newConceptSource = new ConceptSource();

				newConceptSource.setName(implementationId.getName());

				newConceptSource.setDescription(implementationId.getDescription());

				newConceptSource.setHl7Code(implementationId.getImplementationId());

				if (Context.getAuthenticatedUser() == null) // (hackish)

					newConceptSource.setCreator(new User(1)); // fake the user because no one is logged in

				Context.getConceptService().saveConceptSource(newConceptSource);

			}

			

			// serialize and save the ImplementationId to the global properties table

			StringWriter stringWriter = new StringWriter();

			OpenmrsUtil.getSerializer().write(implementationId, stringWriter);

			Context.getAdministrationService().saveGlobalProperty(

			    new GlobalProperty(OpenmrsConstants.GLOBAL_PROPERTY_IMPLEMENTATION_ID, stringWriter.toString()));

		}

		catch (APIException e) {

			throw e;

		}

		catch (Exception e) {

			// pass any other exceptions on up the train

			throw new APIException(e);

		}

		finally {

			// save an empty concept source to the database when something fails?

		}

	}

	

	/**

	 * Checks the remote server for this exact implementation id. Returns the description if 1)

	 * there is no implementation id or 2) there is a implementation id and this passphrase matches

	 * it. In the case of 1), this implementation id and passphrase are saved to the remote server's

	 * database

	 * 

	 * @param implementationId

	 * @param description

	 * @param passphrase

	 * @return the stored description on the remote server

	 * @throws APIException

	 * @throws UnsupportedEncodingException

	 */

	private String checkImplementationIdValidity(String implementationId, String description, String passphrase)

	        throws APIException {

		

		if (!StringUtils.hasLength(implementationId))

			throw new APIException("The implementationid cannot be empty");

		if (!StringUtils.hasLength(description))

			throw new APIException("The description cannot be empty");

		if (!StringUtils.hasLength(passphrase))

			throw new APIException("The passphrase cannot be empty");

		

		// set up the data map to post to the openmrs server

		Map<String, String> data = new HashMap<String, String>();

		data.put("implementationId", implementationId);

		data.put("description", description);

		data.put("passphrase", passphrase);

		

		String response = OpenmrsUtil.postToUrl(OpenmrsConstants.IMPLEMENTATION_ID_REMOTE_CONNECTION_URL, data);

		response = response.trim();

		

		if ("".equals(response)) {

			String ms = Context.getMessageSourceService().getMessage("ImplementationId.connectionError",

			    new String[] { implementationId }, Context.getLocale());

			throw new APIException(ms);

		}

		

		if (log.isDebugEnabled())

			log.debug("Response: " + response);

		

		if (response.startsWith("Success")) {

			response = response.replace("Success", "");

			return response.trim();

		}

		

		String ms = Context.getMessageSourceService().getMessage("ImplementationId.invalidIdorPassphrase",

		    new String[] { description }, Context.getLocale());

		throw new APIException(ms);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getAllowedLocales()

	 */

	public List<Locale> getAllowedLocales() {

		// lazy-load the global locale list and initialize with current global property value

		if (globalLocaleList == null) {

			globalLocaleList = new GlobalLocaleList();

			addGlobalPropertyListener(globalLocaleList);

		}

		

		Set<Locale> allowedLocales = globalLocaleList.getAllowedLocales();

		

		// update the GlobalLocaleList.allowedLocales by faking a global property change

		if (allowedLocales == null) {

			// use a default language of "english" if they have cleared this GP for some reason

			String currentPropertyValue = getGlobalProperty(OpenmrsConstants.GLOBAL_PROPERTY_LOCALE_ALLOWED_LIST,

			    LocaleUtility.getDefaultLocale().toString());

			GlobalProperty allowedLocalesProperty = new GlobalProperty(OpenmrsConstants.GLOBAL_PROPERTY_LOCALE_ALLOWED_LIST,

			        currentPropertyValue);

			globalLocaleList.globalPropertyChanged(allowedLocalesProperty);

			allowedLocales = globalLocaleList.getAllowedLocales();

		}

		

		// allowedLocales is guaranteed to not be null at this point

		return new ArrayList<Locale>(allowedLocales);

	}

	

	/**

	 * Used by spring to set the GlobalLocaleList on this implementation

	 * 

	 * @param gll the GlobalLocaleList object that is registered to the GlobalPropertyListeners as

	 *            well

	 */

	public void setGlobalLocaleList(GlobalLocaleList gll) {

		globalLocaleList = gll;

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getPresentationLocales()

	 */

	public Set<Locale> getPresentationLocales() {

		if (presentationLocales == null) {

			presentationLocales = new HashSet<Locale>();

			Collection<Locale> messageLocales = Context.getMessageSourceService().getLocales();

			List<Locale> allowedLocales = getAllowedLocales();

			for (Locale possibleLocale : messageLocales) {

				if (allowedLocales.contains(possibleLocale)) {

					presentationLocales.add(possibleLocale);

				} else {

					// to be sure, check for language-only matches

					for (Locale allowedLocale : allowedLocales) {

						if (("".equals(allowedLocale.getCountry()) || "".equals(possibleLocale.getCountry()))

						        && (allowedLocale.getLanguage().equals(possibleLocale.getLanguage()))) {

							presentationLocales.add(possibleLocale);

							break;

						}

					}

				}

			}

		}

		return presentationLocales;

	}

	

	/**

	 * @see org.openmrs.api.GlobalPropertyListener#globalPropertyChanged(org.openmrs.GlobalProperty)

	 */

	public void globalPropertyChanged(GlobalProperty newValue) {

		if (newValue.getProperty().equals(OpenmrsConstants.GLOBAL_PROPERTY_LOCALE_ALLOWED_LIST)) {

			// reset the calculated locale values

			presentationLocales = null;

		}

	}

	

	/**

	 * @see org.openmrs.api.GlobalPropertyListener#globalPropertyDeleted(java.lang.String)

	 */

	public void globalPropertyDeleted(String propertyName) {

		// TODO Auto-generated method stub

		

	}

	

	/**

	 * @see org.openmrs.api.GlobalPropertyListener#supportsPropertyName(java.lang.String)

	 */

	public boolean supportsPropertyName(String propertyName) {

		return propertyName.equals(OpenmrsConstants.GLOBAL_PROPERTY_LOCALE_ALLOWED_LIST);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getGlobalPropertyByUuid(java.lang.String)

	 */

	public GlobalProperty getGlobalPropertyByUuid(String uuid) {

		return dao.getGlobalPropertyByUuid(uuid);

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getGlobalPropertyValue(java.lang.String,

	 *      java.lang.Object)

	 */

	@SuppressWarnings("unchecked")

	public <T> T getGlobalPropertyValue(String propertyName, T defaultValue) throws APIException {

		if (defaultValue == null)

			throw new IllegalArgumentException("The defaultValue argument cannot be null");

		

		String propVal = getGlobalProperty(propertyName);

		if (!StringUtils.hasLength(propVal))

			return defaultValue;

		

		try {

			return (T) defaultValue.getClass().getDeclaredConstructor(String.class).newInstance(propVal);

		}

		catch (InstantiationException e) {

			throw new APIException(defaultValue.getClass().getName() + " is not able to be instantiated with value: "

			        + propVal, e);

		}

		catch (NoSuchMethodException e) {

			throw new APIException(defaultValue.getClass().getName() + " does not have a string constructor", e);

		}

		catch (Exception e) {

			log.error("Unable to turn value '" + propVal + "' into type " + defaultValue.getClass().getName(), e);

			return defaultValue;

		}

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#getSystemInformation()

	 */

	public Map<String, Map<String, String>> getSystemInformation() throws APIException {

		Map<String, Map<String, String>> systemInfoMap = new LinkedHashMap<String, Map<String, String>>();

		

		systemInfoMap.put("SystemInfo.title.openmrsInformation", new LinkedHashMap<String, String>() {

			

			private static final long serialVersionUID = 1L;

			

			{

				put("SystemInfo.OpenMRSInstallation.systemDate", new SimpleDateFormat("yyyy-MM-dd").format(Calendar

				        .getInstance().getTime()));

				put("SystemInfo.OpenMRSInstallation.systemTime", new SimpleDateFormat("HH:mm:ss").format(Calendar

				        .getInstance().getTime()));

				put("SystemInfo.OpenMRSInstallation.openmrsVersion", OpenmrsConstants.OPENMRS_VERSION);

				try {

					put("SystemInfo.hostname", InetAddress.getLocalHost().getCanonicalHostName());

				}

				catch (UnknownHostException e) {

					put("SystemInfo.hostname", "Unknown host: " + e.getMessage());

				}

			}

		});

		

		systemInfoMap.put("SystemInfo.title.javaRuntimeEnvironmentInformation", new LinkedHashMap<String, String>() {

			

			Properties properties = System.getProperties();

			

			private static final long serialVersionUID = 1L;

			

			{

				put("SystemInfo.JavaRuntimeEnv.operatingSystem", properties.getProperty("os.name"));

				put("SystemInfo.JavaRuntimeEnv.operatingSystemArch", properties.getProperty("os.arch"));

				put("SystemInfo.JavaRuntimeEnv.operatingSystemVersion", properties.getProperty("os.version"));

				put("SystemInfo.JavaRuntimeEnv.javaVersion", properties.getProperty("java.version"));

				put("SystemInfo.JavaRuntimeEnv.javaVendor", properties.getProperty("java.vendor"));

				put("SystemInfo.JavaRuntimeEnv.jvmVersion", properties.getProperty("java.vm.version"));

				put("SystemInfo.JavaRuntimeEnv.jvmVendor", properties.getProperty("java.vm.vendor"));

				put("SystemInfo.JavaRuntimeEnv.javaRuntimeName", properties.getProperty("java.runtime.name"));

				put("SystemInfo.JavaRuntimeEnv.javaRuntimeVersion", properties.getProperty("java.runtime.version"));

				put("SystemInfo.JavaRuntimeEnv.userName", properties.getProperty("user.name"));

				put("SystemInfo.JavaRuntimeEnv.systemLanguage", properties.getProperty("user.language"));

				put("SystemInfo.JavaRuntimeEnv.systemTimezone", properties.getProperty("user.timezone"));

				put("SystemInfo.JavaRuntimeEnv.fileSystemEncoding", properties.getProperty("sun.jnu.encoding"));

				put("SystemInfo.JavaRuntimeEnv.userDirectory", properties.getProperty("user.dir"));

				put("SystemInfo.JavaRuntimeEnv.tempDirectory", properties.getProperty("java.io.tmpdir"));

			}

		});

		

		systemInfoMap.put("SystemInfo.title.memoryInformation", new LinkedHashMap<String, String>() {

			

			private static final long serialVersionUID = 1L;

			

			Runtime runtime = Runtime.getRuntime();

			

			{

				put("SystemInfo.Memory.totalMemory", convertToMegaBytes(runtime.totalMemory()));

				put("SystemInfo.Memory.freeMemory", convertToMegaBytes(runtime.freeMemory()));

				put("SystemInfo.Memory.maximumHeapSize", convertToMegaBytes(runtime.maxMemory()));

				

			}

		});

		

		systemInfoMap.put("SystemInfo.title.dataBaseInformation", new LinkedHashMap<String, String>() {

			

			Properties properties = Context.getRuntimeProperties();

			

			private static final long serialVersionUID = 1L;

			

			{

				put("SystemInfo.Database.name", OpenmrsConstants.DATABASE_NAME);

				put("SystemInfo.Database.connectionURL", properties.getProperty("connection.url"));

				put("SystemInfo.Database.userName", properties.getProperty("connection.username"));

				put("SystemInfo.Database.driver", properties.getProperty("hibernate.connection.driver_class"));

				put("SystemInfo.Database.dialect", properties.getProperty("hibernate.dialect"));

				

			}

		});

		

		systemInfoMap.put("SystemInfo.title.moduleInformation", new LinkedHashMap<String, String>() {

			

			private static final long serialVersionUID = 1L;

			

			{

				put("SystemInfo.Module.repositoryPath", ModuleUtil.getModuleRepository().getAbsolutePath());

				Collection<Module> loadedModules = ModuleFactory.getLoadedModules();

				for (Module module : loadedModules) {

					String moduleInfo = module.getVersion() + " "

					        + (module.isStarted() ? "" : Context.getMessageSourceService().getMessage("Module.notStarted"));

					put(module.getName(), moduleInfo);

				}

			}

		});

		

		return systemInfoMap;

	}

	

	/**

	 * @param bytes to be converted into mega bytes

	 * @return memory in mega bytes

	 */

	private String convertToMegaBytes(long bytes) {

		int ONE_KILO_BYTE = 1024;

		return String.valueOf(bytes / ONE_KILO_BYTE / ONE_KILO_BYTE) + " MB";

	}

	

	/**

	 * @see org.openmrs.api.AdministrationService#purgeGlobalProperties(java.util.List)

	 */

	@Override

	public void purgeGlobalProperties(List<GlobalProperty> globalProperties) throws APIException {

		for (GlobalProperty globalProperty : globalProperties) {

			Context.getAdministrationService().purgeGlobalProperty(globalProperty);

		}

	}

	

	/**

	 * @see AdministrationService#getMaximumPropertyLength(Class, String)

	 */

	@Override

	public int getMaximumPropertyLength(Class<? extends OpenmrsObject> aClass, String fieldName) {

		return dao.getMaximumPropertyLength(aClass, fieldName);

	}

}