this.nonCodedAllergen = nonCodedAllergen;

		if (StringUtils.isNotBlank(nonCodedAllergen)) {

			if (codedAllergen != null && !codedAllergen.getUuid().equals(getOtherNonCodedConceptUuid())) {

				codedAllergen = null;

			}

	/**

	 * Convenience method that voids all existing attributes of the given type, and sets this new one.

	 * TODO fail if minOccurs > 1

	 * TODO decide whether this should require maxOccurs=1

	 * @should void the attribute if an attribute with same attribute type already exists and the maxOccurs is set to 1

	 * @should work for attributes with datatypes whose values are stored in other tables

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

			}

			// this should be all that is needed unless the encounter has been built by hand

			//if (o.isVoided() == false && o.isObsGrouping() == false)

			//	ret.add(o);

		}

	 */

	public void setAttributeName(String attributeName) {

		// this.dirty = true;

		this.attributeName = attributeName;

	}

	 */

	public boolean isComplex() {

		//		if (getValueComplex() != null) {

		//			return true;

		//		}

	 * as pointers, each individual element is not copied. <br>

	 * <br>

	 * TODO Should the patient specific attributes be copied? (like identifiers)

	 * 

	 * @param person the person object to copy onto a new Patient

	 * @return Returns the "preferred" patient identifier.

	 */

	public PatientIdentifier getPatientIdentifier() {

		// normally the DAO layer returns these in the correct order, i.e. preferred and non-voided first, but it's possible that someone

		// has fetched a Patient, changed their identifiers around, and then calls this method, so we have to be careful.

			for (PatientIdentifier pi : getIdentifiers()) {

				if (!pi.isVoided()) {

					if (pi.isPreferred()) {

						ids.add(pi);

					} else {

	 */

	@SuppressWarnings("squid:S1210")

	public int compareTo(PatientIdentifier other) {

		DefaultComparator piDefaultComparator = new DefaultComparator();

		return piDefaultComparator.compare(this, other);

	private String formatDescription;

	private Boolean checkDigit = Boolean.FALSE;

	private String validator;

	@JsonIgnore

	public Boolean isBirthdateEstimated() {

		// if (this.birthdateEstimated == null) {

		// return new Boolean(false);

		// }

	public boolean hasRole(String r, boolean ignoreSuperUser) {

		if (!ignoreSuperUser) {

			if (isSuperUser()) {

				return true;

			}

		// quick check to make sure we're only being called by ourselves

		//Class<?> callerClass = Reflection.getCallerClass(0);

		Class<?> callerClass = new OpenmrsSecurityManager().getCallerClass(0);

		if (!TimerSchedulerTask.class.isAssignableFrom(callerClass)) {

		for (String property : propertyValues.keySet()) {

			if (changePropertyValue(currentState, propertyNames, property, propertyValues.get(property), setNullOnly)) {

				objectWasChanged = true;

			}

		if (personTypes.contains(PERSON_TYPE.PERSON)) {

			// all observations are already on person's.  Limit to non-patient and non-users here?

			//criteria.createAlias("Person", "person");

			//criteria.add(Restrictions.eqProperty("obs.person.personId", "person.personId"));

		}

package org.openmrs.api.db.hibernate;

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

			// and Persons are the same objects.  So it sees a Person object in the

			// cache and claims it is a duplicate of this Patient object.

			//patient = (Patient) sessionFactory.getCurrentSession().merge(patient);

			sessionFactory.getCurrentSession().saveOrUpdate(patient);

		}

		// TODO add junit test for getting by identifier type

		if (!patientIdentifierTypes.isEmpty()) {

			criteria.add(Restrictions.in("identifierType", patientIdentifierTypes));

		}

		// TODO add junit test for getting by patients

		if (!patients.isEmpty()) {

			criteria.add(Restrictions.in("patient", patients));

			serializedObject.setName(metaObj.getName());

			serializedObject.setDescription(metaObj.getDescription());

			serializedObject.setRetired(metaObj.isRetired() == Boolean.TRUE);

			serializedObject.setRetiredBy(metaObj.getRetiredBy());

			serializedObject.setDateRetired(metaObj.getDateRetired());

		}

		// TODO add a junit test for patientIdentifierType restrictions	

		// do the type restriction

	public List<T> list() {

		//debug

		/*FullTextQuery fullTextQuery = buildQuery();

		fullTextQuery.setProjection(

				FullTextQuery.DOCUMENT_ID,

				}

			} else if (gp.getProperty().equals(OpenmrsConstants.GLOBAL_PROPERTY_DEFAULT_LOCALE)) {

				if (gp.getPropertyValue() != null) {

					List<Locale> localeList = getAllowedLocales();

					if (!localeList.contains(LocaleUtility.fromSpecification(gp.getPropertyValue().trim()))) {

						String value = gp.getPropertyValue();

						gp.setPropertyValue(LocaleUtility.getDefaultLocale().toString());

		}

		Concept conceptToReturn = dao.saveConcept(concept);

		return conceptToReturn;

public class EncounterServiceImpl extends BaseOpenmrsService implements EncounterService {

	// private Log log = LogFactory.getLog(this.getClass());

	private EncounterDAO dao;

	public Form duplicateForm(Form form) throws APIException {

		// Map of /Old FormFieldId/ to /New FormField Object/

		//TreeMap<Integer, FormField> formFieldMap = new TreeMap<Integer, FormField>();

		//formFieldMap.put(null, null); //for parentless formFields

		checkIfFormsAreLocked();

		for (FormField formField : form.getFormFields()) {

			//formFieldMap.put(formField.getFormFieldId(), formField);

			formField.setUuid(null);

			formField.setFormFieldId(null);

			//formField.setParent(formFieldMap.get(formField.getParent().getFormFieldId()));

		}

		// this is required because Hibernate would recognize the original collection

				int minutes = cal.get(Calendar.MINUTE);

				int seconds = cal.get(Calendar.SECOND);

				int milliseconds = cal.get(Calendar.MILLISECOND);

				//roll autoExpireDate to end of day (23:59:59) if no time portion is specified

				if (hours == 0 && minutes == 0 && seconds == 0) {

	public OrderFrequency saveOrderFrequency(OrderFrequency orderFrequency) throws APIException {

		if (orderFrequency.getOrderFrequencyId() != null) {

			if (dao.isOrderFrequencyInUse(orderFrequency)) {

				throw new CannotUpdateObjectInUseException("Order.frequency.cannot.edit");

			}

	 * @see org.openmrs.api.PatientService#savePatient(org.openmrs.Patient)

	 */

	public Patient savePatient(Patient patient) throws APIException {

		if (patient.getPatientId() == null) {

			Context.requirePrivilege(PrivilegeConstants.ADD_PATIENTS);

	 */

	@Transactional(readOnly = true)

	public void checkPatientIdentifiers(Patient patient) throws PatientIdentifierException {

		// check patient has at least one identifier

		if (!patient.isVoided() && patient.getActiveIdentifiers().isEmpty()) {

		}

		List<PatientIdentifier> identifiers = new Vector<PatientIdentifier>();

		identifiers.addAll(patient.getIdentifiers());

		List<String> identifiersUsed = new Vector<String>();

		List<PatientIdentifierType> requiredTypes = Context.getPatientService().getPatientIdentifierTypes(null, null, true,

		    null);

		}

		/*

		 * if (preferred.getRace() == null || preferred.getRace().equals(""))

		 * preferred.setRace(notPreferred.getRace());

		 */

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

	 * @see org.openmrs.api.PersonService#savePerson(org.openmrs.Person)

	 */

	public Person savePerson(Person person) throws APIException {

		PersonName preferredName = null;

		PersonName possiblePreferredName = person.getPersonName();

	 */

	@Transactional(readOnly = true)

	public List<PersonAttributeType> getPersonAttributeTypes(PERSON_TYPE personType, ATTR_VIEW_TYPE viewType)

	        throws APIException {

		AdministrationService as = Context.getAdministrationService();

		final String fatalString = "Should not be here.";

		// TODO cache the global properties to speed this up??

		// Is hibernate taking care of caching and not hitting the db every time? (hopefully it is)

		if (viewType == null) {

		// the java list object to hold the values from the global properties

		List<String> attrNames = new Vector<String>();

		// split the comma delimited string into a java list object

				if (s != null) {

					s = s.trim();

					if (s.length() > 0) {

						attrNames.add(s);

					}

		// the actual list we'll be returning

		List<PersonAttributeType> attrObjects = new Vector<PersonAttributeType>();

		// get the PersonAttribute objects for each name/id

					nextVisit.setStopDatetime(stopDate);

					dao.saveVisit(nextVisit);

					if (counter++ > 50) {

						//ensure changes are persisted to DB before reclaiming memory

						Context.flushSession();

		String name = "";

		if (concept != null) {

			if (concept.getName() != null) {

				name = concept.getName().getName();

			}

		 * Use this code snippet instead if we think that fetching the clob is fast enough

		 * 

		ClobDatatypeStorage storage = Context.getDatatypeService().getClobDatatypeStorageByUuid(referenceString);

		if (storage == null)

			return Context.getMessageSourceService().getMessage("CustomDatatype.error.missingValue");

		// TODO: ideally, we would branch or alter our behavior based on the

		// sending application.

		// String sendingApplication = getSendingApplication(oru);

		// validate message

		}

		HL7Service hl7Service = Context.getHL7Service();

		// create the encounter

		Calendar cal = Calendar.getInstance();

		cal.set(year, month, day, hour, min, sec);

		// if (cal.getTimeZone().getRawOffset() != timeZoneOffsetMillis) {

		// TimeZone tz = (TimeZone)TimeZone.getDefault().clone();

		// tz.setRawOffset(timeZoneOffsetMillis);

		// unused

		// String assigningAuthority = xcn.getAssigningAuthority()

		// .getUniversalID().getValue();

		/*

		 * if ("null".equals(familyName)) familyName = null; if

		 * ("null".equals(givenName)) givenName = null; if

		 * ("null".equals(assigningAuthority)) assigningAuthority = null;

		 */

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

			// log.debug("searching for user by id " + idNumber);

			try {

				Integer userId = Integer.valueOf(idNumber);

			}

		} else {

			// log.debug("searching for user by name");

			try {

				List<User> users = Context.getUserService().getUsersByName(givenName,familyName,true);

					return null;

				}

				else { // size == 0

					// legacy behavior is looking up by username

					StringBuilder username = new StringBuilder();

		// TODO other potential identifying characteristics in PID we could use

		// to identify the patient

		// XPN[] patientName = pid.getPersonName();

		// String gender = pid.getAdministrativeSex().getValue();

		// TS dateOfBirth = pid.getDateTimeOfBirth();

					currToken.put("displaySize", this.getSizeMappings().get(realToken));

					currToken.put("codeName", realToken);

					//numTokens++;

					ret.add(currToken);

				}

					currToken.put("displaySize", this.getSizeMappings().get(realToken));

					currToken.put("codeName", realToken);

					//numTokens++;

					ret.add(currNonToken);

					ret.add(currToken);

						currToken.put("displaySize", this.getSizeMappings().get(realToken));

						currToken.put("codeName", realToken);

						//numTokens++;

						ret.add(currToken);

					}

			currToken.put("displaySize", this.getSizeMappings().get(realToken));

			currToken.put("codeName", realToken);

			//numTokens++;

			ret.add(currToken);

	 */

	public void putAll(Map<? extends String, ? extends PresentationMessage> t) {

		//Map<String, PresentationMessage> compatibleMap = new HashMap<String, PresentationMessage>();

		for (Entry<? extends String, ? extends PresentationMessage> entry : t.entrySet()) {

			put(entry.getKey(), entry.getValue());

		for (Locale locale : localizedMap.keySet()) {

			PresentationMessageMap codeMessageMap = localizedMap.get(locale);

			allMessages.addAll(codeMessageMap.values());

		}

		PatientService ps = Context.getPatientService();

		List<PatientProgram> patientPrograms = new ArrayList<PatientProgram>();

		//List<PatientState> patientStates = new ArrayList<PatientState>();

		Map<String, PatientProgram> knownPatientPrograms = new HashMap<String, PatientProgram>();

		Map<String, Program> programsByName = new HashMap<String, Program>();

				String[] temp = s.split(",");

				/* We're using a cache of 'knownPatientPrograms' instead of the following commented code

				PatientIdentifierType pit = ps.getPatientIdentifierType(temp[0]);

				String identifier = temp[1];

				List<PatientIdentifier> pis = ps.getPatientIdentifiers(identifier, pit);

					throw new RuntimeException("Couldn't find program \"" + temp[2] + "\" in " + programsByName);

				}

				//ProgramWorkflow wf = pws.getWorkflow(program, temp[3]);

				ProgramWorkflow wf = program.getWorkflowByName(temp[3]);

				if (wf == null) {

					        + program.getAllWorkflows() + ")");

				}

				//ProgramWorkflowState st = pws.getState(wf, temp[4]);

				ProgramWorkflowState st = wf.getStateByName(temp[4]);

				if (st == null) {

	 * This is also used to fix: https://tickets.openmrs.org/browse/TRUNK-4053

	 */

	private Map<String, Class<?>> loadedClasses = new HashMap<String, Class<?>>();

	/**

		String libname = System.mapLibraryName(name);

		String result = null;

		//TODO

		//PathResolver pathResolver = ModuleFactory.getPathResolver();

		//		for (Library lib : getModule().getLibraries()) {

		//			if (lib.isCodeLibrary()) {

		//				if (log.isDebugEnabled()) {

		//					log.debug("findLibrary(String): URL " + libUrl

		//							+ " resolved as local file " + libFile);

		//				}

		//				if (libFile.isFile()) {

		//			// we have some kind of non-local URL

		//			// try to copy it to local temporary file

		//			libFile = (File) libraryCache.get(libUrl);

		//			if (libFile != null) {

		//				if (libFile.isFile()) {

		//			if (libraryCache.containsKey(libUrl)) {

		//				// already tried to cache this library

		//				break;

		//			}

		//			libFile = cacheLibrary(libUrl, libname);

			}

		}

		//		if (resourceLoader != null) {

		//			for (Enumeration enm = resourceLoader.findResources(name);

		//					enm.hasMoreElements();) {

		Map<String, Module> loadedModulesMap = getLoadedModulesMapPackage();

		for (String key : loadedModules.keySet()) {

			Module m = loadedModules.get(key);

			Map<String, String> startBeforeModules = m.getStartBeforeModulesMap();

			if (startBeforeModules.size() > 0) {

		Map<String, Module> map = new WeakHashMap<String, Module>();

		for (String key : loadedModules.keySet()) {

			map.put(loadedModules.get(key).getPackageName(), loadedModules.get(key));

		}

		return map;

				// into spring yet.  All advice for all modules must be reloaded

				// a spring context refresh anyway, so skip the advice loading here

				// loadAdvice(module);

				// map extension point to a list of extensions for this module only

				if (packagesProvided.add(packageName)) {

					if (log.isTraceEnabled()) {

						log.trace("Adding module's jarentry with package: " + packageName);

					}

			// getting here means we passed in no user or a blank user.

			// a null recipient column means get stuff for the anonymous user

			//crit.add(Expression.isNull("recipient.recipient"));

			// returning an empty list for now because the above throws an error.

		User user = Context.getUserService().getUser(recipientId);

		message.addRecipient(user.getUserProperty(OpenmrsConstants.USER_PROPERTY_NOTIFICATION_ADDRESS));

		// message.setFormat( user( OpenmrsConstants.USER_PROPERTY_NOTIFICATION_FORMAT ) );

		Context.getMessageService().sendMessage(message);

	}

			message.addRecipient(address);

		}

		// message.setFormat( user.getProperty( OpenmrsConstants.USER_PROPERTY_NOTIFICATION_FORMAT ) );

		Context.getMessageService().sendMessage(message);

	}

		MimeMessage mimeMessage = new MimeMessage(session);

		// TODO Need to test the null case.  

		// Transport should use default mail.from value defined in properties.

		if (message.getSender() != null) {

			title = title.replace("." + extension, "");

			outputfile = new File(dir, title + "." + extension);

			// outputfile = new File(dir, title);

		}

		} else if (file.delete()) {

			obs.setComplexData(null);

			// obs.setValueComplex(null);

			return true;

		}

	}

	//public void setPriorDateOfDeathEstimated(boolean priorDateOfDeathEstimated) {

	public void setPriorDateOfDeathEstimated(Boolean priorDateOfDeathEstimated) {

		this.priorDateOfDeathEstimated = priorDateOfDeathEstimated;

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class CohortEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public CohortEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		if (StringUtils.hasText(text)) {

			try {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class ConceptAnswerEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public ConceptAnswerEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		ConceptService cs = Context.getConceptService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		ConceptService conceptService = Context.getConceptService();

		if (Context.isAuthenticated() && StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class ConceptClassEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public ConceptClassEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		log.debug("Setting text: " + text);

		ConceptService cs = Context.getConceptService();

				setValue(cs.getConceptClass(Integer.valueOf(text)));

			}

			catch (Exception ex) {

				ConceptClass conceptClass = cs.getConceptClassByUuid(text);

				setValue(conceptClass);

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class ConceptDatatypeEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public ConceptDatatypeEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		log.debug("setting text: " + text);

		ConceptService cs = Context.getConceptService();

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class ConceptEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public ConceptEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		ConceptService cs = Context.getConceptService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class ConceptNameEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public ConceptNameEditor() {

	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		ConceptService cs = Context.getConceptService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class ConceptNumericEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public ConceptNumericEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		ConceptService cs = Context.getConceptService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class ConceptSourceEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public ConceptSourceEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		log.debug("Setting text: " + text);

		ConceptService cs = Context.getConceptService();

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class DrugEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public DrugEditor() {

	 * @should fail if drug does not exist with non-empty identifier

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		ConceptService es = Context.getConceptService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class EncounterEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public EncounterEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		EncounterService es = Context.getEncounterService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class EncounterTypeEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public EncounterTypeEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		EncounterService ps = Context.getEncounterService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class FormEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public FormEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		FormService ps = Context.getFormService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		LocationService ls = Context.getLocationService();

		if (Context.isAuthenticated() && StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class LocationEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public LocationEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		LocationService ls = Context.getLocationService();

		if (StringUtils.hasText(text)) {

		Location t = (Location) getValue();

		if (t == null && Context.isAuthenticated()) {

			return null; //return Context.getAuthenticatedUser().getUserProperty(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCATION);

		} else {

			if (t != null) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class LocationTagEditor extends PropertyEditorSupport {

	private static Log log = LogFactory.getLog(LocationTagEditor.class);

	public LocationTagEditor() {

	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		LocationService ls = Context.getLocationService();

		if (Context.isAuthenticated() && StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class OrderEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	/**

	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		OrderService ps = Context.getOrderService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class PatientEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	/**

	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		PatientService ps = Context.getPatientService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class PatientIdentifierTypeEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public PatientIdentifierTypeEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		PatientService ps = Context.getPatientService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class PersonAttributeEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	/**

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		PersonService ps = Context.getPersonService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class PersonAttributeTypeEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	/**

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		PersonService ps = Context.getPersonService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class ProgramWorkflowEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public ProgramWorkflowEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		ProgramWorkflowService pws = Context.getProgramWorkflowService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class ProgramWorkflowStateEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public ProgramWorkflowStateEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		ProgramWorkflowService pws = Context.getProgramWorkflowService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class UserEditor extends PropertyEditorSupport {

	private Log log = LogFactory.getLog(this.getClass());

	public UserEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		UserService ps = Context.getUserService();

		if (StringUtils.hasText(text)) {

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class VisitEditor extends PropertyEditorSupport {

	private static final Log log = LogFactory.getLog(VisitEditor.class);

	public VisitEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		VisitService vs = Context.getVisitService();

		if (StringUtils.hasText(text)) {

				setValue(vs.getVisit(Integer.valueOf(text)));

			}

			catch (Exception ex) {

				Visit v = vs.getVisitByUuid(text);

				setValue(v);

/**

 * This Source Code Form is subject to the terms of the Mozilla Public License,

public class VisitTypeEditor extends PropertyEditorSupport {

	private static final Log log = LogFactory.getLog(VisitTypeEditor.class);

	public VisitTypeEditor() {

	 * @should set using uuid

	 */

	public void setAsText(String text) throws IllegalArgumentException {

		VisitService vs = Context.getVisitService();

		if (StringUtils.hasText(text)) {

				setValue(vs.getVisitType(Integer.valueOf(text)));

			}

			catch (Exception ex) {

				VisitType v = vs.getVisitTypeByUuid(text);

				setValue(v);

	public static final int DAYS_PER_WEEK = 7;

	//public static DEFAULT_DATE_FORMAT = new SimpleDateFormat("MM-dd-yyyy hh:mm:ss");

	public static final int DAILY = MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE * MINUTES_PER_HOUR;

	public static final int WEEKLY = DAILY * DAYS_PER_WEEK;

	//public static final int MONTHLY; 

	//public static final int ANNUALLY;

	 * @param startTime start time for the task

	 */

	/*	public void setStartTime(String startTime) { 

			try {

		            this.startTime = this.dateFormatter.parse(startTime);

			catch (Exception e) { 

				//If there's an error, we'll just set the start time to now.

				// TODO: This might not be the desired behavior, so I'll have to come back to it.

		             this.startTime = new	             Date(); 

		             }

package org.openmrs.scheduler;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.util.Calendar;

import java.util.Date;

	 * @throws DAOException

	 */

	//public void createSchedule(Schedule schedule) throws DAOException;

	/**

	 * Get schedule by internal identifier

	 * @throws DAOException

	 */

	//public void updateSchedule(Schedule schedule) throws DAOException;

	/**

	 * Get all schedules.

	 * @throws DAOException

	 */

	//public Set<Schedule> getSchedules() throws DAOException;

	/**

	 * Delete schedule from database.

	 * @throws DAOException

	 */

	//public void deleteSchedule(Schedule schedule) throws DAOException;

}

	 * @throws DAOException

	 */

	//public void createSchedule(Schedule schedule) throws DAOException;

	/**

	 * Get schedule by internal identifier

	 * @throws DAOException

	 */

	//public void updateSchedule(Schedule schedule) throws DAOException;

	/**

	 * Get all schedules.

	 * @throws DAOException

	 */

	//public Set<Schedule> getAllSchedules() throws DAOException;

	/**

	 * Delete schedule from database.

	 * @throws DAOException

	 */

	//public void deleteSchedule(Schedule schedule) throws DAOException;	

}

			TimerSchedulerTask schedulerTask = scheduledTasks.get(taskDefinition.getId());

			if (schedulerTask != null) {

				//schedulerTask.cancel();					

				log.info("Shutting down the existing instance of this task to avoid conflicts!!");

				schedulerTask.shutdown();

				// returning null causes the field to be blanked out

				//return null;

			}

		}

	 * @should always have a valid update to latest file

	 */

	public static boolean updatesRequired() throws Exception {

		log.debug("checking for updates");

		List<OpenMRSChangeSet> changesets = getUnrunDatabaseChanges();

	 */

	@Authorized(PrivilegeConstants.GET_DATABASE_CHANGES)

	public static List<OpenMRSChangeSet> getUnrunDatabaseChanges() throws Exception {