private void addRangeInternal(IntRange theRange)
	{
		int searchResult = Collections.binarySearch(m_ranges, theRange, s_intRangeComparator);
		
		if (searchResult >= 0)
		{
			// The given range intersects with the range at the result index.
			IntRange currentRange = m_ranges.get(searchResult);
			if (currentRange.containsRange(theRange))
			{
				// Nothing to do: the range provided doesn't add any open time.
			}
			else if (theRange.containsRange(currentRange))
			{
				// Replace the range in the list with the new range
				m_ranges.remove(searchResult);
				m_ranges.add(searchResult, theRange);
			}
			else
			{
				// Create a new range with the minimum of the two minimums and the maximum of the two maximums.
				int newMinimum = minimum(currentRange.getMinimumInteger(), theRange.getMinimumInteger());
				int newMaximum = maximum(currentRange.getMaximumInteger(), theRange.getMaximumInteger());
				IntRange newRange = new IntRange(newMinimum, newMaximum);
				m_ranges.remove(searchResult);
				m_ranges.add(searchResult, newRange);
			}
		}
		else
		{
			// No intersection, and search has returned -(insertionPoint + 1)
			int insertionPoint = -searchResult - 1;
			m_ranges.add(insertionPoint, theRange);
		}
	}
	
	private int minimum(int a, int b)
	{
		if (a < b)
		{
			return a;
		}
		else
		{
			return b;
		}
	}
	
	private int maximum(int a, int b)
	{
		if (a > b)
		{
			return a;
		}
		else
		{
			return b;
		}
	}

		String key = (String)System.getProperties().get(m_propertyName);
		if (key == null)
		{
			return null;
		}
		else
		{
			return m_runModeMap.get(key);
		}
	}
	
	@Required
	public void setRunModeMap(Map<String,String> runModeMap)
	{
		m_runModeMap = new HashMap<String,RunMode>(Math.round(runModeMap.size()/0.75f));
		for (Map.Entry<String, String> thisEntry : runModeMap.entrySet())
		{
			m_runModeMap.put(thisEntry.getKey(), RunMode.valueOf(thisEntry.getValue()));
		}
	}
	
	@Required
	public void setPropertyName(String propertyName)
	{
		m_propertyName = propertyName;
	}
}

        Address address = location.getAddress();
        
        if (address != null)
        {
            // TODO consider setting special system user, or just embedding the
            // address object in the Hibernate sense. --Alf
            // Make sure the user is null, so this address doesn't show up in any
            // user's list of addresses.
            address.setUser(null);
    
            // TODO Fix this mess somehow so that we can just pass the address directly to the geocoder.
            org.promotego.api.geocoder.beans.Address geocoderAddress =
                    new org.promotego.api.geocoder.beans.Address(address.getStreetAddress(), address.getCity(), address.getState(), address.getPostalCode(), address.getCountry());
            
            GeocodeResult result;
            try
            {
                result = m_geocoder.geocode(geocoderAddress);
            }
            catch(GeocodeException e)
            {
                // TODO catch exception and render to user
                throw NestedException.wrap(e);
            }
            
            // TODO Check geocode precision to see if it matches expected value
            address.setGeolocation(result.getGeolocation());
        }
        
        m_locationDao.update(location);

        return new ModelAndView(getSuccessView(), myModel);
    }

    @SuppressWarnings("unchecked")
    @Transactional(readOnly=true)
    @Override
    protected ModelAndView showForm(HttpServletRequest request, HttpServletResponse response, BindException errors, Map controlModel) throws Exception
    {
        Map <String,Object>myControlModel;
        
        // Create a new Map, leaving the original untouched.
        if (controlModel == null)
        {
            myControlModel = new HashMap<String,Object>();
        }
        else
        {
            myControlModel = new HashMap<String,Object>(controlModel);
        }
        
        // Populate location types for filtering functionality
        List<LocationType> locationTypes = m_locationTypeDao.findAll();
        Collections.sort(locationTypes);
        myControlModel.put("locationTypes", locationTypes);

        org.promotego.api.geocoder.beans.Address geocoderAddress =
                new org.promotego.api.geocoder.beans.Address(address.getStreetAddress(), address.getCity(), address.getState(), address.getPostalCode(), address.getCountry());
        
        GeocodeResult result;
        try
        {
            result = m_geocoder.geocode(geocoderAddress);
        }
        catch(GeocodeException e)
        {
            // TODO catch exception and render to user
            throw NestedException.wrap(e);
        }
        
        // TODO Check geocode precision to see if it matches expected value
        address.setGeolocation(result.getGeolocation());

    public void setDuration(int duration)
    {
        m_duration = duration;
    }
    
    @ManyToOne
    public Location getLocation()
    {
        return m_location;
    }
    
    public void setLocation(Location location)
    {
        m_location = location;
    }
    
    @ManyToOne
    public User getOfferer()
    {
        return m_offerer;
    }
    
    public void setOfferer(User offerer)
    {
        m_offerer = offerer;
    }
    
    @Temporal(value=TemporalType.TIMESTAMP)
    public Date getStartTime()
    {
        return m_startTime;
    }
    
    public void setStartTime(Date startTime)
    {
        m_startTime = startTime;
    }

        return new ModelAndView("redirect:showofferedgames.do", "messageKey", "gameOffer.cancelled");
    }

    @Override
    protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception
    {
        binder.registerCustomEditor(OfferedGame.class, new BeanIdEditor<OfferedGame>(m_offeredGameDao));
        
        super.initBinder(request, binder);
    }

    @Required
    public void setOfferedGameDao(OfferedGameDao offeredGameDao)
    {
        m_offeredGameDao = offeredGameDao;
    }

    @Required
    public void setUserHolder(UserHolder userHolder)
    {
        m_userHolder = userHolder;
    }

        model.put("offeredGame", offeredGame);
        
        return new ModelAndView(getSuccessView(), model);
    }

	@SuppressWarnings("unchecked")
    @Override
    protected ModelAndView showForm(HttpServletRequest request, HttpServletResponse response, BindException errors, Map controlModel) throws Exception
    {
        Map<String,Object> myControlModel = new HashMap<String, Object>();
        
        if (controlModel != null)
        {
            myControlModel.putAll(controlModel);
        }

    	Location theLocation = (Location)target;
    	
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "required", "Name is required.");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "phoneNumber", "required", "Phone number is required.");
        
        if (!theLocation.getPhoneNumber().matches("[0-9]{3}-[0-9]{3}-[0-9]{4}"))
        {
        	errors.rejectValue("phoneNumber", "incorrectFormat", "Phone number must have format XXX-XXX-XXXX.");
        }
        
        m_addressValidator.validate(((Location)target).getAddress(), errors);

		for (int i=0; i<theList.size(); i++)
		{
			for (int j=i+1; j<theList.size(); j++)
			{
				HourSpecification spec1 = theList.get(i);
				HourSpecification spec2 = theList.get(j);
				
				if (spec1.sameHours(spec2))

	public void addRange(IntRange theRange)
	{
		if (theRange.getMinimumInteger() >= StoreHours.SECONDS_IN_WEEK)
		{
			throw new IllegalArgumentException("Range must begin with a number less than the number of seconds in a week");
		}

		if (theRange.getMaximumInteger() > StoreHours.SECONDS_IN_WEEK)
		{
			// Range needs to be split before adding
			IntRange range1 = new IntRange(theRange.getMinimumInteger(), StoreHours.SECONDS_IN_WEEK);

        m_locationDao.update(location);
        
        Map<String, Object> model = new HashMap<String, Object>();
        model.put("locationId", location.getId());
        model.put("messageKey", "location.saved");
        
        return new ModelAndView(getSuccessView(), model);
    }
    
    @Override

        myControlModel.put("searchRadii", s_searchRadii);
        
        return super.showForm(request, response, errors, myControlModel);
    }
    
    @Override
    protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception
    {
        binder.registerCustomEditor(LocationType.class, new BeanIdEditor<LocationType>(m_locationTypeDao));

public class ListLocationsController extends AbstractController
{
    private UserHolder m_userHolder;
    private UserDao m_userDao;

    @Override
    protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception
    {
        assert m_userHolder.getUser() != null : "User object may not be null";
        m_userDao.reattach(m_userHolder.getUser());
        List<Location> locations = m_userHolder.getUser().getLocations();

    @Transactional
    @Override
    protected ModelAndView handle(HttpServletRequest request,
            HttpServletResponse response, Object command, BindException errors)
            throws Exception
    {
        OfferedGame offeredGame = ((OfferedGameHolder)command).getOfferedGame();
        
        assert m_userHolder.getUser() != null : "User object may not be null";

        return new ModelAndView("userProfile", "profileUser", theUser);
    }

    @Override
    protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception
    {
        binder.registerCustomEditor(User.class, new BeanIdEditor<User>(m_userDao));
        
        super.initBinder(request, binder);
    }

    }

    @Required
    public void setUserHolder(UserHolder userHolder)
    {
        m_userHolder = userHolder;
    }

    @Required
    public void setMailSender(MailSender mailSender)
    {
        m_mailSender = mailSender;
    }

    @Required
    public void setBaseUrl(String baseUrl)
    {
        m_baseUrl = baseUrl;
    }

    }

    public String getState()
    {
        return m_state;
    }

    public void setState(String state)
    {
        m_state = state;
    }

    public String getStreetAddress()
    {
        return m_streetAddress;
    }

    public void setStreetAddress(String streetAddress)
    {
        m_streetAddress = streetAddress;
    }

				if (spec1.sameHours(spec2))
				{
					assert j > i : "j must be greater than i";
					
					// We have to remove j first, because it's greater than i.  Otherwise,
					// we will end up removing the wrong element after all the indices shift.
					theList.remove(j);
					theList.remove(i);
					theList.add(i, spec1.mergeWith(spec2));
					
					// We've reduced the size of the list, but we replaced the element
					// at i.  Just reduce the j index.
					j--;
				}
			}
		}

public class ShowSystemPropertiesController extends AbstractController
{
	@Override
	protected ModelAndView handleRequestInternal(HttpServletRequest request,
			HttpServletResponse response) throws Exception
	{
		Map<String,Object> model = new HashMap<String, Object>();
		model.put("heading", "System Properties:");

	@Override
	protected ModelAndView handleRequestInternal(HttpServletRequest request,
			HttpServletResponse response) throws Exception
	{
		Map<String,Object> model = new HashMap<String, Object>();
		model.put("heading", "System Status:");

    @Transactional
    @Override
    public ModelAndView onSubmit(Object command)
    {
        Location location = ((LocationCommandBean)command).getLocation();
        assert m_userHolder.getUser() != null : "User object may not be null";

public class ShowOfferedGamesController extends AbstractController
{
    private UserHolder m_userHolder;
    private UserDao m_userDao;

    @Override
    protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception
    {
        assert m_userHolder.getUser() != null : "User object may not be null";

        myControlModel.put("searchRadii", m_metadataHelper.getSearchRadii());
        
        return super.showForm(request, response, errors, myControlModel);
    }
    
    @Override
    protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception
    {
        binder.registerCustomEditor(Address.class, new BeanIdEditor<Address>(m_addressDao));

public class EnforceValidationInterceptor extends ExcludingInterceptorBase
{
	private UserHolder m_userHolder;

	@Override
	public boolean excludingPreHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception
	{
		if (m_userHolder.getUser() != null && m_userHolder.getUser().isValidated())

        binder.registerCustomEditor(Address.class, new BeanIdEditor<Address>(m_addressDao));
        
        super.initBinder(request, binder);
    }
    
    @Required
    public void setUserHolder(UserHolder theUserHolder)

    }
    
    @Required
    public void setOfferedGameDao(OfferedGameDao offeredGameDao)
    {
        m_offeredGameDao = offeredGameDao;
    }

    @Required
    public void setUserHolder(UserHolder userHolder)
    {
        m_userHolder = userHolder;
    }

    @Required
    public void setMailSender(MailSender mailSender)

        return new ModelAndView("showOfferedGames", "offeredGames", offeredGames);
    }
    
    @Required
    public void setUserHolder(UserHolder theUserHolder)
    {
        m_userHolder = theUserHolder;
    }

    @Required
	public void setUserDao(UserDao userDao) {
		m_userDao = userDao;
	}
}

	}

	@Required
	public void setMailSender(MailSender mailSender)
	{
		m_mailSender = mailSender;
	}

	@Required
    public void setBaseUrl(String baseUrl)
    {
        m_baseUrl = baseUrl;
    }
}

        		+ scheduledGame.getId());

        m_mailSender.send(msg);
	}

	@Required
	public void setScheduledGameDao(ScheduledGameDao scheduledGameDao)
	{
		m_scheduledGameDao = scheduledGameDao;
	}

	@Required
	public void setTimeBetweenRuns(long timeBetweenRuns)

    }

    @Required
    public void setMailSender(MailSender mailSender)
    {
        m_mailSender = mailSender;
    }

    @Required
    public void setBaseUrl(String baseUrl)
    {
        m_baseUrl = baseUrl;
    }
}