UserPrefsTool.java

/**********************************************************************************
 * $URL: https://source.sakaiproject.org/svn/user/trunk/user-tool-prefs/tool/src/java/org/sakaiproject/user/tool/UserPrefsTool.java $
 * $Id: UserPrefsTool.java 131540 2013-11-14 16:11:49Z a.fish@lancaster.ac.uk $
 ***********************************************************************************
 *
 * Copyright (c) 2005, 2006, 2007, 2008 The Sakai Foundation
 *
 * Licensed under the Educational Community License, Version 2.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://www.opensource.org/licenses/ECL-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **********************************************************************************/

package org.sakaiproject.user.tool;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
import java.util.Vector;

import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.event.ValueChangeEvent;
import javax.faces.model.SelectItem;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.sakaiproject.component.cover.ComponentManager;
import org.sakaiproject.component.cover.ServerConfigurationService;
import org.sakaiproject.entity.api.ResourceProperties;
import org.sakaiproject.entity.api.ResourcePropertiesEdit;
import org.sakaiproject.event.cover.NotificationService;
import org.sakaiproject.exception.IdUnusedException;
import org.sakaiproject.site.api.Site;
import org.sakaiproject.site.api.SiteService.SelectionType;
import org.sakaiproject.site.api.SiteService.SortType;
import org.sakaiproject.site.cover.SiteService;
import org.sakaiproject.time.cover.TimeService;
import org.sakaiproject.tool.api.SessionManager;
import org.sakaiproject.tool.api.ToolSession;
import org.sakaiproject.user.api.Preferences;
import org.sakaiproject.user.api.PreferencesEdit;
import org.sakaiproject.user.api.PreferencesService;
import org.sakaiproject.user.api.UserNotificationPreferencesRegistration;
import org.sakaiproject.user.api.UserNotificationPreferencesRegistrationService;
import org.sakaiproject.util.ResourceLoader;


/**
 * UserPrefsTool is the Sakai end-user tool to view and edit one's preferences.
 */
public class UserPrefsTool
{
	/** Our log (commons). */
	private static final Log LOG = LogFactory.getLog(UserPrefsTool.class);

	/** * Resource bundle messages */
	ResourceLoader msgs = new ResourceLoader("user-tool-prefs");

	/** The string that Charon uses for preferences. */
	private static final String CHARON_PREFS = "sakai:portal:sitenav";

	/** The string to get whether privacy status should be visible */
	private static final String ENABLE_PRIVACY_STATUS = "enable.privacy.status";

	/** Should research/collab specific preferences (no syllabus) be displayed */
	private static final String PREFS_RESEARCH = "prefs.research.collab";
	
	public static final String PREFS_EXPAND = "prefs.expand";
	private static final String PREFS_EXPAND_TRUE = "1";
	private static final String PREFS_EXPAND_FALSE = "0";

	/**
	 * Represents a name value pair in a keyed preferences set.
	 */
	public class KeyNameValue
	{
		/** Is this value a list?. */
		protected boolean m_isList = false;

		/** The key. */
		protected String m_key = null;

		/** The name. */
		protected String m_name = null;

		/** The original is this value a list?. */
		protected boolean m_origIsList = false;

		/** The original key. */
		protected String m_origKey = null;

		/** The original name. */
		protected String m_origName = null;

		/** The original value. */
		protected String m_origValue = null;

		/** The value. */
		protected String m_value = null;

		public KeyNameValue(String key, String name, String value, boolean isList)
		{
			m_key = key;
			m_origKey = key;
			m_name = name;
			m_origName = name;
			m_value = value;
			m_origValue = value;
			m_isList = isList;
			m_origIsList = isList;
		}

		public String getKey()
		{
			return m_key;
		}

		public String getName()
		{
			return m_name;
		}

		public String getOrigKey()
		{
			return m_origKey;
		}

		public String getOrigName()
		{
			return m_origName;
		}

		public String getOrigValue()
		{
			return m_origValue;
		}

		public String getValue()
		{
			return m_value;
		}

		public boolean isChanged()
		{
			return ((!m_name.equals(m_origName)) || (!m_value.equals(m_origValue)) || (!m_key.equals(m_origKey)) || (m_isList != m_origIsList));
		}

		public boolean isList()
		{
			return m_isList;
		}

		public boolean origIsList()
		{
			return m_origIsList;
		}

		public void setKey(String value)
		{
			if (!m_key.equals(value))
			{
				m_key = value;
			}
		}

		public void setList(boolean b)
		{
			m_isList = b;
		}

		public void setName(String value)
		{
			if (!m_name.equals(value))
			{
				m_name = value;
			}
		}

		public void setValue(String value)
		{
			if (!m_value.equals(value))
			{
				m_value = value;
			}
		}
	}

	/** The PreferencesEdit being worked on. */
	protected PreferencesEdit m_edit = null;

	/** Preferences service (injected dependency) */
	protected PreferencesService m_preferencesService = null;
	
	protected UserNotificationPreferencesRegistrationService m_userNotificationPreferencesRegistrationService = null;

	/** Session manager (injected dependency) */
	protected SessionManager m_sessionManager = null;

	/** The PreferencesEdit in KeyNameValue collection form. */
	protected Collection m_stuff = null;

	// /** The user id (from the end user) to edit. */
	// protected String m_userId = null;
	/** For display and selection of Items in JSF-- edit.jsp */
	private List prefExcludeItems = new ArrayList();

	private List prefOrderItems = new ArrayList();

	private List prefTimeZones = new ArrayList();

	private List<SelectItem> prefLocales = new ArrayList<SelectItem>();

	private int DEFAULT_TAB_COUNT = 4;
	private int MAX_TAB_COUNT = 20;
	private int MIN_TAB_COUNT = 2;

	private String prefTabCount = null;

	// SAK-23895
       	private String prefTabLabel = null;
       	private int DEFAULT_TAB_LABEL = 1;

	private String[] selectedExcludeItems;

	private String[] selectedOrderItems;

	private String prefTabString = null;
	private String prefDrawerString = null;
	private String prefHiddenString = null;

	private String[] tablist;

	private int noti_selection, tab_selection, timezone_selection, language_selection, privacy_selection,j;

	//The preference list names
	private String Notification="prefs_noti_title";
	private String CustomTab="prefs_tab_title";
	private String Timezone="prefs_timezone_title";
	private String Language="prefs_lang_title";
	private String Privacy="prefs_privacy_title";
	
	private boolean refreshMode=false;

	protected final static String EXCLUDE_SITE_LISTS = "exclude";

	protected final static String ORDER_SITE_LISTS = "order";

	protected boolean isNewUser = false;

	protected boolean tabUpdated = false;

	// user's currently selected time zone
	private TimeZone m_timeZone = null;

	// user's currently selected regional language locale
	private Locale m_locale = null;

	/** The user id retrieved from UsageSessionService */
	private String userId = "";

	/**
	 * SAK-11460:  With DTHML More Sites, there are potentially two
	 * "Customize Tab" pages, namely "tab.jsp" (for the Drag and Drop)
	 * and "tab-dhtml-moresites.jsp".  Which one is used depends on the
	 * sakai.properties "prefs.tabs.dragdrop".
	 */
	private String m_TabOutcome = "tab";
	
	private Map<String, Integer> m_sortedTypes = new HashMap<String, Integer>();
	private List<DecoratedNotificationPreference> m_registereddNotificationItems = new ArrayList<DecoratedNotificationPreference>();	
	private List<Site> m_sites = new ArrayList<Site>();

	// SAK-23895
	private boolean prefShowTabLabelOption = true;
	
	// //////////////////////////////// PROPERTY GETTER AND SETTER ////////////////////////////////////////////

	public boolean isPrefShowTabLabelOption() {
	    return prefShowTabLabelOption;
	}

	public void setPrefShowTabLabelOption(boolean prefShowTabLabelOption) {
	    this.prefShowTabLabelOption = prefShowTabLabelOption;
	}

	/**
	 * @return Returns the prefExcludeItems.
	 */
	public List getPrefExcludeItems()
	{	
		return prefExcludeItems;
	}

	/**
	 * @param prefExcludeItems
	 *        The prefExcludeItems to set.
	 */
	public void setPrefExcludeItems(List prefExcludeItems)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setPrefExcludeItems(List " + prefExcludeItems + ")");
		}

		this.prefExcludeItems = prefExcludeItems;
	}

	/**
	 * @return Returns the prefOrderItems.
	 */
	public List getPrefOrderItems()
	{
		return prefOrderItems;
	}

	/**
	 * @param prefOrderItems
	 *        The prefOrderItems to set.
	 */
	public void setPrefOrderItems(List prefOrderItems)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setPrefOrderItems(List " + prefOrderItems + ")");
		}

		this.prefOrderItems = prefOrderItems;
	}

	/**
	 * @return Returns the prefTabItems.
	 */
	public List getPrefTabItems()
	{
		int tc = getTabCountInt();

                List<SelectItem> l = new ArrayList<SelectItem>();
                for (int i = 0; i < prefOrderItems.size() && i < tc-1; i++)
                {
                        SelectItem item = (SelectItem) prefOrderItems.get(i);
			l.add(item);
                }
		return l;
	}

	/**
	 * @return Returns the prefDrawerItems.
	 */
	public List getPrefDrawerItems()
	{
		int tc = getTabCountInt();
		if ( tc < 1 ) tc = 1;

                List<SelectItem> l = new ArrayList<SelectItem>();
                for (int i = tc-1; i < prefOrderItems.size(); i++)
                {
                        SelectItem item = (SelectItem) prefOrderItems.get(i);
			l.add(item);
                }
		return l;
	}

	/**
	 * @return Returns the prefHiddenItems.
	 */
	public List getPrefHiddenItems()
	{	
		return prefExcludeItems;
	}

	public String getPrefTabString()
	{
		return "";
	}

	public void setPrefTabString(String inp)
	{
		inp = inp.trim();
		prefTabString = inp;
		if ( inp.length() < 1 ) prefTabString = null;
		return;
	}

	public String getPrefDrawerString()
	{
		return "";
	}

	public void setPrefDrawerString(String inp)
	{
		inp = inp.trim();
		prefDrawerString = inp;
		if ( inp.length() < 1 ) prefDrawerString = null;
		return;
	}

	public String getPrefHiddenString()
	{
		return "";
	}

	public void setPrefHiddenString(String inp)
	{
		inp = inp.trim();
		prefHiddenString = inp;
		if ( inp.length() < 1 ) prefHiddenString = null;
		return;
	}

	/**
	 ** @return number of worksite tabs to display in standard site navigation bar
	 **/
	public String getTabCount()
	{
		if ( prefTabCount != null )
			return prefTabCount;

		Preferences prefs = (PreferencesEdit) m_preferencesService.getPreferences(getUserId());
		ResourceProperties props = prefs.getProperties(CHARON_PREFS);
		prefTabCount = props.getProperty("tabs");

		if ( prefTabCount == null )
			prefTabCount = String.valueOf(DEFAULT_TAB_COUNT);

		return prefTabCount;
	}

	/**
	 ** @return number of worksite tabs to display in standard site navigation bar
	 **/
	public int getTabCountInt()
	{
                String tcs = getTabCount();
                int tc = DEFAULT_TAB_COUNT;
                try
                {
                        tc = Integer.parseInt(tcs.trim());
                }
                catch(Exception e){
                        tc = DEFAULT_TAB_COUNT;
                }
		return tc;
	}

	/**
	 * @return the listing of valid tab choices
	 */
	public List<SelectItem> getTabsChoices() {
	    if (MAX_TAB_COUNT <= DEFAULT_TAB_COUNT) {
	        // force max to be larger than default
	        MAX_TAB_COUNT = DEFAULT_TAB_COUNT + 10;
	    }
	    List<SelectItem> l = new ArrayList<SelectItem>(MAX_TAB_COUNT);
	    for (int i = 0; i < MAX_TAB_COUNT; i++) {
	        int tabNum = i + 1;
	        if (tabNum >= DEFAULT_TAB_COUNT) {
	            String value = String.valueOf(tabNum);
	            l.add( new SelectItem( value, value ) );
	        }
        }
	    return l;
	}

	/**
	 ** @param count 
	 **			number of worksite tabs to display in standard site navigation bar
	 **/
	public void setTabCount( String count )
	{
		if ( count == null || "".equals(count.trim()) ) {
			count = String.valueOf(DEFAULT_TAB_COUNT);
		} else {
			count = count.trim();
		}
		// make sure this is a valid number
		int countInt;
        try {
            countInt = Integer.parseInt(count);
        } catch (NumberFormatException e) {
            countInt = DEFAULT_TAB_COUNT;
        }
		if ( countInt > 0 && countInt >= DEFAULT_TAB_COUNT && countInt <= MAX_TAB_COUNT ) {
            this.prefTabCount = count;
		} else {
		    this.prefTabCount = String.valueOf(DEFAULT_TAB_COUNT);
		}
	}

	/**
	 * @return Returns the prefTimeZones.
	 */
	public List getPrefTimeZones()
	{
		if (prefTimeZones.size() == 0)
		{
			String[] timeZoneArray = TimeZone.getAvailableIDs();
			Arrays.sort(timeZoneArray);
			for (int i = 0; i < timeZoneArray.length; i++)
				prefTimeZones.add(new SelectItem(timeZoneArray[i], timeZoneArray[i]));
		}

		return prefTimeZones;
	}

	/**
	 * @param prefTimeZones
	 *        The prefTimeZones to set.
	 */
	public void setPrefTimeZones(List prefTimeZones)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setPrefTimeZones(List " + prefTimeZones + ")");
		}

		this.prefTimeZones = prefTimeZones;
	}

	/**
	 * @return Returns the prefLocales
	 */
	public List<SelectItem> getPrefLocales()
	{
		// Initialize list of supported locales, if necessary
		if (prefLocales.isEmpty())
		{
		    org.sakaiproject.component.api.ServerConfigurationService scs = (org.sakaiproject.component.api.ServerConfigurationService) ComponentManager.get(org.sakaiproject.component.api.ServerConfigurationService.class);
		    Locale[] localeArray = scs.getSakaiLocales();
			for (int i = 0; i < localeArray.length; i++)
			{
				if (i == 0 || !localeArray[i].equals(localeArray[i - 1])) {
					prefLocales.add(new SelectItem(localeArray[i].toString(), msgs.getLocaleDisplayName(localeArray[i])));
				}
			}
		}

		return prefLocales;
	}

	/**
	 * @param prefLocales
	 *        The prefLocales to set.
	 */
	public void setPrefLocales(List prefLocales)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setPrefLocales(List " + prefLocales + ")");
		}

		this.prefLocales = prefLocales;
	}

	/**
	 * @return Returns the selectedExcludeItems.
	 */
	public String[] getSelectedExcludeItems()
	{
		return selectedExcludeItems;
	}

	/**
	 * @param selectedExcludeItems
	 *        The selectedExcludeItems to set.
	 */
	public void setSelectedExcludeItems(String[] selectedExcludeItems)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setSelectedExcludeItems(String[] " + Arrays.toString(selectedExcludeItems) + ")");
		}

		this.selectedExcludeItems = selectedExcludeItems;
	}

	/**
	 * @return Returns the selectedOrderItems.
	 */
	public String[] getSelectedOrderItems()
	{
		return selectedOrderItems;
	}

	/**
	 * @param selectedOrderItems
	 *        The selectedOrderItems to set.
	 */
	public void setSelectedOrderItems(String[] selectedOrderItems)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setSelectedOrderItems(String[] " + Arrays.toString(selectedOrderItems) + ")");
		}

		this.selectedOrderItems = selectedOrderItems;
	}

	/**
	 * @return Returns the user's selected TimeZone ID
	 */
	public String getSelectedTimeZone()
	{
		if (m_timeZone != null) return m_timeZone.getID();

		Preferences prefs = (PreferencesEdit) m_preferencesService.getPreferences(getUserId());
		ResourceProperties props = prefs.getProperties(TimeService.APPLICATION_ID);
		String timeZone = props.getProperty(TimeService.TIMEZONE_KEY);

		if (hasValue(timeZone))
			m_timeZone = TimeZone.getTimeZone(timeZone);
		else
			m_timeZone = TimeZone.getDefault();

		return m_timeZone.getID();
	}

	/**
	 * @param selectedTimeZone
	 *        The selectedTimeZone to set.
	 */
	public void setSelectedTimeZone(String selectedTimeZone)
	{
		if (selectedTimeZone != null)
			m_timeZone = TimeZone.getTimeZone(selectedTimeZone);
		else
			LOG.warn(this + "setSelctedTimeZone() has null TimeZone");
	}

	/**
	 * @return Returns the user's selected Locale ID
	 */
	private Locale getSelectedLocale()
	{
		if (m_locale != null) return m_locale;

		Preferences prefs = (PreferencesEdit) m_preferencesService.getPreferences(getUserId());
		ResourceProperties props = prefs.getProperties(ResourceLoader.APPLICATION_ID);
		String prefLocale = props.getProperty(ResourceLoader.LOCALE_KEY);

		if (hasValue(prefLocale)) {
		    org.sakaiproject.component.api.ServerConfigurationService scs = (org.sakaiproject.component.api.ServerConfigurationService) ComponentManager.get(org.sakaiproject.component.api.ServerConfigurationService.class);
			m_locale = scs.getLocaleFromString(prefLocale);
		} else {
			m_locale = Locale.getDefault();
		}

		return m_locale;
	}

	/**
	 * @return Returns the user's selected Locale ID
	 */
	public String getSelectedLocaleName()
	{
		return getSelectedLocale().getDisplayName();
	}

	/**
	 * @return Returns the user's selected Locale ID
	 */
	public String getSelectedLocaleString()
	{
		return getSelectedLocale().toString();
	}

	/**
	 * @param selectedLocale
	 *        The selectedLocale to set.
	 */
	public void setSelectedLocaleString(String selectedLocale)
	{
		if (selectedLocale != null) {
		    org.sakaiproject.component.api.ServerConfigurationService scs = (org.sakaiproject.component.api.ServerConfigurationService) ComponentManager.get(org.sakaiproject.component.api.ServerConfigurationService.class);
		    m_locale = scs.getLocaleFromString(selectedLocale);
		}
	}

	/**
	 * @return Returns the userId.
	 */
	public String getUserId()
	{
		return m_sessionManager.getCurrentSessionUserId();
	}

	/**
	 * @param userId
	 *        The userId to set.
	 */
	public void setUserId(String userId)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setUserId(String " + userId + ")");
		}
		this.userId = userId;
	}

	/**
	 * @param mgr
	 *        The preferences service.
	 */
	public void setPreferencesService(PreferencesService mgr)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setPreferencesService(PreferencesService " + mgr + ")");
		}

		m_preferencesService = mgr;
	}

	public void setUserNotificationPreferencesRegistrationService(
			UserNotificationPreferencesRegistrationService userNotificationPreferencesRegistrationService) {
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setUserNotificationPreferencesRegistrationService(UserNotificationPreferencesRegistrationService " + userNotificationPreferencesRegistrationService + ")");
		}
		m_userNotificationPreferencesRegistrationService = userNotificationPreferencesRegistrationService;
	}

	/**
	 * @param mgr
	 *        The session manager.
	 */
	public void setSessionManager(SessionManager mgr)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setSessionManager(SessionManager " + mgr + ")");
		}

		m_sessionManager = mgr;
	}

	/**
	 * @return Returns the tabUpdated.
	 */
	public boolean isTabUpdated()
	{
		return tabUpdated;
	}

	/**
	 * @param tabUpdated
	 *        The tabUpdated to set.
	 */
	public void setTabUpdated(boolean tabUpdated)
	{
		this.tabUpdated = tabUpdated;
	}
	
	/**
	 * Init some services that are needed.  
	 * Unfortunately they were needed when the constructor was called so 
	 * injecting wasn't soon enough.
	 */
	private void initServices() {
		if (m_userNotificationPreferencesRegistrationService == null) {
			m_userNotificationPreferencesRegistrationService = (UserNotificationPreferencesRegistrationService)ComponentManager.get("org.sakaiproject.user.api.UserNotificationPreferencesRegistrationService");
		}
		
		if (m_preferencesService == null) {
			m_preferencesService = (PreferencesService)ComponentManager.get("org.sakaiproject.user.api.PreferencesService");
		}
		
		if (m_sessionManager == null) {
			m_sessionManager = (SessionManager)ComponentManager.get("org.sakaiproject.tool.api.SessionManager");
		}
	}

	// /////////////////////////////////////// CONSTRUCTOR ////////////////////////////////////////////
	/**
	 * no-arg constructor.
	 */
	public UserPrefsTool()
	{
		// Is DTHML more site enabled?
		if (ServerConfigurationService.getBoolean ("prefs.tabs.dragdrop", true))
			m_TabOutcome = "tab";
		else
			m_TabOutcome = "tabDHTMLMoreSites";

		// do we show the option to display by site title or short description?
		boolean show_tab_label_option = ServerConfigurationService.getBoolean("preference.show.tab.label.option", true);
		setPrefShowTabLabelOption(show_tab_label_option);

		//Tab order configuration
		String defaultPreference="prefs_tab_title, prefs_noti_title, prefs_timezone_title, prefs_lang_title";

		if (ServerConfigurationService.getString("preference.pages")== null || ServerConfigurationService.getString("preference.pages").length() == 0)
		{
			LOG.info("The preference.pages is not specified in sakai.properties, hence the default option of 'prefs_tab_title, prefs_noti_title, prefs_timezone_title, prefs_lang_title' is considered");
		}
		else
		{
			LOG.debug("Setting preference.pages as "+ ServerConfigurationService.getString("preference.pages"));
		}
		
		//To indicate that it is in the refresh mode
		refreshMode=true;
		String tabOrder=ServerConfigurationService.getString("preference.pages",defaultPreference);

		tablist=tabOrder.split(",");

		for(int i=0; i<tablist.length; i++)
		{
			tablist[i]=tablist[i].trim();			
			if(tablist[i].equals(Notification)) noti_selection=i+1;
			else if(tablist[i].equals(CustomTab)) tab_selection=i+1;
			else if(tablist[i].equals(Timezone)) timezone_selection=i+1;
			else if (tablist[i].equals(Language)) language_selection=i+1;
			else if (tablist[i].equals(Privacy)) privacy_selection=i+1;
			else LOG.warn(tablist[i] + " is not valid!!! Re-configure preference.pages at sakai.properties");
		}

		//defaultPage=tablist[0];

		// Set the default tab count to the system property, initially.
		String tabCountConfig = ServerConfigurationService.getString ("portal.default.tabs", String.valueOf(DEFAULT_TAB_COUNT));
		try {
            int value = Integer.valueOf(tabCountConfig.trim());
            if (value <= 0 || value > 100) {
                throw new NumberFormatException(tabCountConfig + " is out of valid range (0 .. 100)");
            }
            DEFAULT_TAB_COUNT = value;
        } catch (NumberFormatException e) {
            LOG.warn("Invalid portal.default.tabs value specified ("+tabCountConfig+") must specify a number between 0 and 100, default to "+DEFAULT_TAB_COUNT+": "+e);
        }
        String tabCountMaxConfig = ServerConfigurationService.getString ("portal.max.tabs", String.valueOf(MAX_TAB_COUNT));
        try {
            int value = Integer.valueOf(tabCountMaxConfig.trim());
            if (value <= 0 || value > 100 || value <= DEFAULT_TAB_COUNT) {
                throw new NumberFormatException(tabCountMaxConfig + " is out of valid range (0 .. 100) OR <= default tab count ("+DEFAULT_TAB_COUNT+")");
            }
            MAX_TAB_COUNT = value;
        } catch (NumberFormatException e) {
            LOG.warn("Invalid portal.default.tabs value specified ("+tabCountConfig+") must specify a number between 0 and 100, default to "+MAX_TAB_COUNT+": "+e);
        }
		
		initNotificationStructures();
		LOG.debug("new UserPrefsTool()");
	}
	
	/**
	 * Init a bunch of stuff that we'll need for the notification preferences
	 */
	private void initNotificationStructures() {
		
		initServices();
		
		//Get my sites
		m_sites = SiteService.getSites(SelectionType.ACCESS, null, null, null,
				SortType.TITLE_ASC, null);
		
		initRegisteredNotificationItems();
		
		
	}

	public int getNoti_selection()
	{
		//Loading the data for notification in the refresh mode
		if (noti_selection==1 && refreshMode==true)
		{
			processActionNotiFrmEdit();
		}
		return noti_selection;
	}

	public int getTab_selection()
	{
		//Loading the data for customize tab in the refresh mode
		if (tab_selection==1 && (refreshMode==true|| (prefOrderItems.isEmpty() && prefExcludeItems.isEmpty()) )) //SAK-16572
		{
			processActionEdit();
		}
		return tab_selection;
	}

	public int getTimezone_selection()
	{
		//Loading the data for timezone in the refresh mode
		if (timezone_selection==1 && refreshMode==true)
		{
			processActionTZFrmEdit();
		}
		
		return timezone_selection;
	}

	public int getLanguage_selection()
	{
		//Loading the data for language in the refresh mode
		if (language_selection==1 && refreshMode==true)
		{
			processActionLocFrmEdit();
		}
		return language_selection;
	}
	
	public int getPrivacy_selection()
	{
		//Loading the data for notification in the refresh mode
		if (privacy_selection==1 && refreshMode==true)
		{
			processActionPrivFrmEdit();
		}
		return privacy_selection;
	}



	public String getTabTitle()
	{
		return "tabtitle";
	}

	// Naming in faces-config.xml Refresh jsp- "refresh" , Notification jsp- "noti" , tab cutomization jsp- "tab"
	// ///////////////////////////////////// PROCESS ACTION ///////////////////////////////////////////
	/**
	 * Process the add command from the edit view.
	 * 
	 * @return navigation outcome to tab customization page (edit)
	 */
	public String processActionAdd()
	{
		LOG.debug("processActionAdd()");
		tabUpdated = false; // reset successful text message if existing with same jsp
		String[] values = getSelectedExcludeItems();
		if (values.length < 1)
		{
			FacesContext.getCurrentInstance().addMessage(null,
					new FacesMessage(msgs.getString("add_to_sites_msg")));
			return m_TabOutcome;
		}

		for (int i = 0; i < values.length; i++)
		{
			String value = values[i];
			getPrefOrderItems().add(removeItems(value, getPrefExcludeItems(), ORDER_SITE_LISTS, EXCLUDE_SITE_LISTS));
		}
		return m_TabOutcome;
	}

	/**
	 * Process remove from order list command
	 * 
	 * @return navigation output to tab customization page (edit)
	 */
	public String processActionRemove()
	{
		LOG.debug("processActionRemove()");
		tabUpdated = false; // reset successful text message if existing in jsp
		String[] values = getSelectedOrderItems();
		if (values.length < 1)
		{
			FacesContext.getCurrentInstance().addMessage(null,
					new FacesMessage(msgs.getString("remove_from_sites_msg")));
			return m_TabOutcome;
		}

		for (int i = 0; i < values.length; i++)
		{
			String value = values[i];
			getPrefExcludeItems().add(removeItems(value, getPrefOrderItems(), EXCLUDE_SITE_LISTS, ORDER_SITE_LISTS));
		}
		return m_TabOutcome;
	}

	/**
	 * Process Add All action
	 * 
	 * @return navigation output to tab customization page (edit)
	 */
	public String processActionAddAll()
	{
		LOG.debug("processActionAddAll()");

		getPrefOrderItems().addAll(getPrefExcludeItems());
		getPrefExcludeItems().clear();
		tabUpdated = false; // reset successful text message if existing in jsp
		return m_TabOutcome;
	}

	/**
	 * Process Remove All command
	 * 
	 * @return navigation output to tab customization page (edit)
	 */
	public String processActionRemoveAll()
	{
		LOG.debug("processActionRemoveAll()");

		getPrefExcludeItems().addAll(getPrefOrderItems());
		getPrefOrderItems().clear();
		tabUpdated = false; // reset successful text message if existing in jsp
		return m_TabOutcome;
	}

	/**
	 * Move Up the selected item in Ordered List
	 * 
	 * @return navigation output to tab customization page (edit)
	 */
	public String processActionMoveUp()
	{
		LOG.debug("processActionMoveUp()");
		return doSiteMove(true, false); //moveUp = true, absolute = false
	}

	/**
	 * Move down the selected item in Ordered List
	 * 
	 * @return navigation output to tab customization page (edit)
	 */
	public String processActionMoveDown()
	{
		LOG.debug("processActionMoveDown()");
		return doSiteMove(false, false); //moveUp = false, absolute = false
	}

	public String processActionMoveTop()
	{
		LOG.debug("processActionMoveTop()");
		return doSiteMove(true, true); //moveUp = true, absolute = true
	}

	public String processActionMoveBottom()
	{
		LOG.debug("processActionMoveBottom()");
		return doSiteMove(false, true); //moveUp = false, absolute = true
	}

	private String doSiteMove(boolean moveUp, boolean absolute) {
		tabUpdated = false;
		Set<String> selected   = new HashSet(Arrays.asList(getSelectedOrderItems()));
		List<SelectItem> toMove = new ArrayList<SelectItem>();

		//Prune bad selections and split lists if moving absolutely
		for (Iterator i = prefOrderItems.iterator(); i.hasNext(); ) {
			SelectItem item = (SelectItem) i.next();
			if (selected.contains(item.getValue())) {
				toMove.add(item);
				if (absolute)
					i.remove();
			}
		}

		if (toMove.size() == 0) {
			String message = msgs.getString(moveUp ? "move_up_msg" : "move_down_msg");
			FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(message));
		}
		else {
			if (absolute) {
				//Move the selected list, in order to the right spot.
				if (moveUp)
					prefOrderItems.addAll(0, toMove);
				else
					prefOrderItems.addAll(toMove);
			}
			else {
				//Iterate in the right direction
				int start = 0;
				int interval = 1;
				int end = prefOrderItems.size() - 1;

				if (!moveUp) {
					start = prefOrderItems.size() - 1;
					interval = -1;
					end = 0;
				}

				for (int i = start; i != end; i += interval) {
					SelectItem cur  = (SelectItem) prefOrderItems.get(i);
					SelectItem next = (SelectItem) prefOrderItems.get(i + interval);
					if (toMove.contains(next) && !toMove.contains(cur)) {
						prefOrderItems.set(i, next);
						prefOrderItems.set(i + interval, cur);
						toMove.remove(next);
					}
				}
			}
		}
		return m_TabOutcome;

	}

	/**
	 * Process the edit command.
	 * 
	 * @return navigation outcome to tab customization page (edit)
	 */
	public String processActionEdit()
	{
		LOG.debug("processActionEdit()");

		if (!hasValue(getUserId()))
		{
			FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(msgs.getString("user_missing")));
			return null;
		}
		tabUpdated = false; // Reset display of text message on JSP
		refreshMode=false;

		setUserEditingOn();

		prefTabCount = null;
		prefExcludeItems = new ArrayList();
		prefOrderItems = new ArrayList();
		List prefExclude = new Vector();
		List prefOrder = new Vector();

		Preferences prefs = m_preferencesService.getPreferences(getUserId());
		ResourceProperties props = prefs.getProperties(CHARON_PREFS);
		List l = props.getPropertyList("exclude");
		if (l != null)
		{
			prefExclude = l;
		}

		l = props.getPropertyList("order");
		if (l != null)
		{
			prefOrder = l;
		}

		List mySites = SiteService.getSites(org.sakaiproject.site.api.SiteService.SelectionType.ACCESS, null, null, null,
				org.sakaiproject.site.api.SiteService.SortType.TITLE_ASC, null);
		// create excluded and order list of Sites and add balance mySites to excluded Site list for display in Form
		List ordered = new Vector();
		List excluded = new Vector();
		for (Iterator i = prefOrder.iterator(); i.hasNext();)
		{
			String id = (String) i.next();
			// find this site in the mySites list
			int pos = indexOf(id, mySites);
			if (pos != -1)
			{
				// move it from mySites to order
				Site s = (Site) mySites.get(pos);
				ordered.add(s);
				mySites.remove(pos);
			}
		}
		for (Iterator iter = prefExclude.iterator(); iter.hasNext();)
		{
			String element = (String) iter.next();
			int pos = indexOf(element, mySites);
			if (pos != -1)
			{
				Site s = (Site) mySites.get(pos);
				excluded.add(s);
				mySites.remove(pos);
			}
		}
		// pick up the rest of the sites if not available with exclude and order list
		// and add to the ordered list as when a new site is created it is displayed in header
		ordered.addAll(mySites);

		// Now convert to SelectItem for display in JSF
                String sitetablabel = getPrefTabLabel();
		for (Iterator iter = excluded.iterator(); iter.hasNext();)
		{
			Site element = (Site) iter.next();
			// some short descriptins are empty or null
			String shortdesc = element.getShortDescription();
			if ((shortdesc == null) || ("".equals(shortdesc))){
			    shortdesc = element.getTitle();
			}

			SelectItem excludeItem = null;

			if ("1".equals(sitetablabel)) {
			    excludeItem = new SelectItem(element.getId(), element.getTitle());
			}
			else {
			    excludeItem = new SelectItem(element.getId(), shortdesc);
			}
			prefExcludeItems.add(excludeItem);
		}

		for (Iterator iter = ordered.iterator(); iter.hasNext();)
		{
			Site element = (Site) iter.next();

			// some short descriptins are empty or null
			String shortdesc = element.getShortDescription();
			if ((shortdesc == null) || ("".equals(shortdesc))){
			    shortdesc = element.getTitle();
			}

			SelectItem orderItem = null;
			if ("1".equals(sitetablabel)) {
			    orderItem = new SelectItem(element.getId(), element.getTitle());
			}
			else {
			    orderItem = new SelectItem(element.getId(), shortdesc);
			}

			prefOrderItems.add(orderItem);
		}

		// release lock
		m_preferencesService.cancel(m_edit);
		return m_TabOutcome;
	}

	/**
	 * Process the save command from the edit view.
	 * 
	 * @return navigation outcome to tab customization page (edit)
	 */
	public String processActionSave()
	{
		LOG.debug("processActionSave()");

		setUserEditingOn();
		// Remove existing property
		ResourcePropertiesEdit props = m_edit.getPropertiesEdit(CHARON_PREFS);
		props.removeProperty("exclude");
		props.removeProperty("order");
		// Commit to remove from database, for next set of value storing
		m_preferencesService.commit(m_edit);

		m_stuff = new Vector();
		String oparts = "";
		String eparts = "";
		for (int i = 0; i < prefExcludeItems.size(); i++)
		{
			SelectItem item = (SelectItem) prefExcludeItems.get(i);
			String evalue = (String) item.getValue();
			eparts += evalue + ", ";
		}
		for (int i = 0; i < prefOrderItems.size(); i++)
		{
			SelectItem item = (SelectItem) prefOrderItems.get(i);
			String value = (String) item.getValue();
			oparts += value + ", ";
		}
		// add property name and value for saving
		m_stuff.add(new KeyNameValue(CHARON_PREFS, "exclude", eparts, true));
		m_stuff.add(new KeyNameValue(CHARON_PREFS, "order", oparts, true));
		m_stuff.add(new KeyNameValue(CHARON_PREFS, "tabs", prefTabCount, false));
		m_stuff.add(new KeyNameValue(CHARON_PREFS, "tab:label", prefTabLabel, false));

		// save
		saveEdit();
		// release lock and clear session variables
		cancelEdit();
		// To stay on the same page - load the page data
		processActionEdit();
		tabUpdated = true; // set for display of text message on JSP

		m_reloadTop = Boolean.TRUE;

		return m_TabOutcome;
	}

	/**
	 * Process the save command from the edit view.
	 * 
	 * @return navigation outcome to tab customization page (edit)
	 */
	public String processActionSaveOrder()
	{
		LOG.debug("processActionSaveOrder()");

		// No tabs, nothing to do 
		if ( prefTabString == null && prefDrawerString == null && prefHiddenString == null ) {

			// SAK-23895 , we need to save the tab label preference even though there is no drag-drop actions. 
			// Lydia: I hate to duplicate updatePrefs() code here. Can we call something like updatePrefs(null, null, null)? 
			m_stuff = new Vector();
			m_stuff.add(new KeyNameValue(CHARON_PREFS, "tab:label", prefTabLabel, false));
			// save
			saveEdit();
			// release lock and clear session variables
			cancelEdit();
			// To stay on the same page - load the page data
			processActionEdit();
			tabUpdated = true; // set for display of text message on JSP
			m_reloadTop = Boolean.TRUE;

			return m_TabOutcome;
		}

		String error = "";
		if ( prefTabString == null ) {
			error = msgs.getString("remove_all");
			FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR,error, null));
			return m_TabOutcome;
		}
		String [] ids = prefTabString.split(",");
		int tabcount = ids.length + 1;
		if ( tabcount <  MIN_TAB_COUNT && prefDrawerString == null && prefHiddenString == null ) tabcount = DEFAULT_TAB_COUNT;
		if ( tabcount <  MIN_TAB_COUNT ) {
			error = msgs.getString("min_tabs");
			error = error.format(error,MIN_TAB_COUNT);
			FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR,error, null));
			return m_TabOutcome;
		}

		String order = prefTabString;
		if ( prefDrawerString != null ) {
			order += ", " + prefDrawerString;
		}

		updatePrefs(order, prefHiddenString, tabcount);

		return m_TabOutcome;
	}

	private void updatePrefs(String order, String excludes, int tabcount) 
	{
		setUserEditingOn();
		// Remove existing property
		ResourcePropertiesEdit props = m_edit.getPropertiesEdit(CHARON_PREFS);
		props.removeProperty("exclude");
		props.removeProperty("order");
		// Commit to remove from database, for next set of value storing
		m_preferencesService.commit(m_edit);

		m_stuff = new Vector();
		// add property name and value for saving
		if ( order != null && order.length() > 0 ) 
			m_stuff.add(new KeyNameValue(CHARON_PREFS, "order", order, true));
		if ( excludes != null && excludes.length() > 0 ) 
			m_stuff.add(new KeyNameValue(CHARON_PREFS, "exclude", excludes, true));
		m_stuff.add(new KeyNameValue(CHARON_PREFS, "tabs",  String.valueOf(tabcount), false));
		m_stuff.add(new KeyNameValue(CHARON_PREFS, "tab:label", prefTabLabel, false));

		// save
		saveEdit();
		// release lock and clear session variables
		cancelEdit();
		// To stay on the same page - load the page data
		processActionEdit();
		tabUpdated = true; // set for display of text message on JSP

		m_reloadTop = Boolean.TRUE;
	}

	/**
	 * Process the cancel command from the edit view.
	 * 
	 * @return navigation outcome to tab customization page (edit)
	 */
	public String processActionCancel()
	{
		LOG.debug("processActionCancel()");

		prefTabCount = null; // reset to retrieve original prefs
		prefTabLabel = null; // reset to retrieve original prefs

		// remove session variables
		cancelEdit();
		// To stay on the same page - load the page data
		processActionEdit();
		return m_TabOutcome;
	}

	/**
	 * Process the cancel command from the edit view.
	 * 
	 * @return navigation outcome to Notification page (list)
	 */
	public String processActionNotiFrmEdit()
	{
		LOG.debug("processActionNotiFrmEdit()");
		refreshMode=false;
		cancelEdit();
		// navigation page data are loaded through getter method as navigation is the default page for 'sakai.preferences' tool.
		return "noti";
	}

	/**
	 * Process the cancel command from the edit view.
	 * 
	 * @return navigation outcome to timezone page (list)
	 */
	public String processActionTZFrmEdit()
	{
		LOG.debug("processActionTZFrmEdit()");

		refreshMode=false;
		cancelEdit();
		// navigation page data are loaded through getter method as navigation is the default page for 'sakai.preferences' tool.
		return "timezone";
	}

	/**
	 * Process the cancel command from the edit view.
	 * 
	 * @return navigation outcome to locale page (list)
	 */
	public String processActionLocFrmEdit()
	{
		LOG.debug("processActionLocFrmEdit()");

		refreshMode=false;
		cancelEdit();
		// navigation page data are loaded through getter method as navigation is the default page for 'sakai.preferences' tool.
		return "locale";
	}

	/**
	 * Process the cancel command from the edit view.
	 * 
	 * @return navigation outcome to locale page (list)
	 */
	public String processActionPrivFrmEdit()
	{
		LOG.debug("processActionPrivFrmEdit()");

		cancelEdit();
		// navigation page data are loaded through getter method as navigation is the default page for 'sakai.preferences' tool.
		return "privacy";
	}

	/**
	 * This is called from edit page for navigation to refresh page
	 * 
	 * @return navigation outcome to refresh page (refresh)
	 */
	public String processActionRefreshFrmEdit()
	{
		LOG.debug("processActionRefreshFrmEdit()");

		// is required as user editing is set on while entering to tab customization page
		cancelEdit();
		loadRefreshData();
		return "refresh";
	}

	// //////////////////////////////////// HELPER METHODS TO ACTIONS ////////////////////////////////////////////
	/**
	 * Cancel the edit and cleanup.
	 */
	protected void cancelEdit()
	{
		LOG.debug("cancelEdit()");

		// cleanup
		m_stuff = null;
		m_edit = null;
		prefExcludeItems = new ArrayList();
		prefOrderItems = new ArrayList();
		isNewUser = false;

		tabUpdated = false;
		notiUpdated = false;
		tzUpdated = false;
		locUpdated = false;
		refreshUpdated = false;
	}

	/**
	 * used with processActionAdd() and processActionRemove()
	 * 
	 * @return SelectItem
	 */
	private SelectItem removeItems(String value, List items, String addtype, String removetype)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("removeItems(String " + value + ", List " + items + ", String " + addtype + ", String " + removetype + ")");
		}

		SelectItem result = null;
		for (int i = 0; i < items.size(); i++)
		{
			SelectItem item = (SelectItem) items.get(i);
			if (value.equals(item.getValue()))
			{
				result = (SelectItem) items.remove(i);
				break;
			}
		}
		return result;
	}

	/**
	 * Set editing mode on for user and add user if not existing
	 */
	protected void setUserEditingOn()
	{
		LOG.debug("setUserEditingOn()");

		try
		{
			m_edit = m_preferencesService.edit(getUserId());
		}
		catch (IdUnusedException e)
		{
			try
			{
				m_edit = m_preferencesService.add(getUserId());
				isNewUser = true;
			}
			catch (Exception ee)
			{
				FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(ee.toString()));
			}
		}
		catch (Exception e)
		{
			FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(e.toString()));
		}
	}

	/**
	 * Save any changed values from the edit and cleanup.
	 */
	protected void saveEdit()
	{
		LOG.debug("saveEdit()");

		// user editing is required as commit() disable isActive() flag
		setUserEditingOn();
		// move the stuff from m_stuff into the edit
		if (m_stuff != null)
		{
			for (Iterator i = m_stuff.iterator(); i.hasNext();)
			{
				KeyNameValue knv = (KeyNameValue) i.next();
				// find the original to remove (unless this one was new)
				if (!knv.getOrigKey().equals(""))
				{
					ResourcePropertiesEdit props = m_edit.getPropertiesEdit(knv.getOrigKey());
					props.removeProperty(knv.getOrigName());
				}
				// add the new if we have a key and name and value
				if ((!knv.getKey().equals("")) && (!knv.getName().equals("")) && (!knv.getValue().equals("")))
				{
					ResourcePropertiesEdit props = m_edit.getPropertiesEdit(knv.getKey());
					if (knv.isList())
					{
						// split by ", "
						String[] parts = knv.getValue().split(", ");
						for (int p = 0; p < parts.length; p++)
						{
							props.addPropertyToList(knv.getName(), parts[p]);
						}
					}
					else
					{
						props.addProperty(knv.getName(), knv.getValue());
					}
				}
			}
		}
		// save the preferences, release the edit
		m_preferencesService.commit(m_edit);
	}

	/**
	 * Check String has value, not null
	 * 
	 * @return boolean
	 */
	protected boolean hasValue(String eval)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("hasValue(String " + eval + ")");
		}

		if (eval != null && !eval.trim().equals(""))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	// Copied from CheronPortal.java
	/**
	 * Find the site in the list that has this id - return the position. *
	 * 
	 * @param value
	 *        The site id to find.
	 * @param siteList
	 *        The list of Site objects.
	 * @return The index position in siteList of the site with site id = value, or -1 if not found.
	 */
	protected int indexOf(String value, List siteList)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("indexOf(String " + value + ", List " + siteList + ")");
		}

		for (int i = 0; i < siteList.size(); i++)
		{
			Site site = (Site) siteList.get(i);
			if (site.getId().equals(value))
			{
				return i;
			}
		}
		return -1;
	}

	// ////////////////////////////////// NOTIFICATION ACTIONS ////////////////////////////////
	
	private DecoratedNotificationPreference currentDecoratedNotificationPreference = null;
	
	protected boolean notiUpdated = false;

	protected boolean tzUpdated = false;

	protected boolean locUpdated = false;

	// ///////////////////////////////// GETTER AND SETTER ///////////////////////////////////
	// TODO chec for any preprocessor for handling request for first time. This can simplify getter() methods as below
	
	/**
	 * @return Returns the notiUpdated.
	 */
	public boolean getNotiUpdated()
	{
		return notiUpdated;
	}

	/**
	 * @param notiUpdated
	 *        The notiUpdated to set.
	 */
	public void setNotiUpdated(boolean notiUpdated)
	{
		this.notiUpdated = notiUpdated;
	}

	/**
	 * @return Returns the tzUpdated.
	 */
	public boolean getTzUpdated()
	{
		return tzUpdated;
	}

	/**
	 * @param notiUpdated
	 *        The tzUpdated to set.
	 */
	public void setTzUpdated(boolean tzUpdated)
	{
		this.tzUpdated = tzUpdated;
	}

	/**
	 * @return Returns the tzUpdated.
	 */
	public boolean getLocUpdated()
	{
		return locUpdated;
	}

	/**
	 * @param notiUpdated
	 *        The locUpdated to set.
	 */
	public void setLocUpdated(boolean locUpdated)
	{
		this.locUpdated = locUpdated;
	}

	// ///////////////////////////////////////NOTIFICATION ACTION - copied from NotificationprefsAction.java////////
	// TODO - clean up method call. These are basically copied from legacy legacy implementations.
	/**
	 * Process the save command from the edit view.
	 * 
	 * @return navigation outcome to notification page
	 */
	public String processActionNotiSave()
	{
		LOG.debug("processActionNotiSave()");

		// get an edit
		setUserEditingOn();
		if (m_edit != null)
		{
			
			List<DecoratedNotificationPreference> items = getRegisteredNotificationItems();
			for(UserNotificationPreferencesRegistration upr : m_userNotificationPreferencesRegistrationService.getRegisteredItems()) {
				readTypePrefs(upr.getType(), upr.getPrefix(), m_edit, getSelectedNotificationItemByKey(upr.getType(), items));
				
				DecoratedNotificationPreference dnp = getDecoItemByKey(upr.getType(), items);
				if (dnp != null) {
					readOverrideTypePrefs(upr.getType() + NotificationService.NOTI_OVERRIDE_EXTENSION, upr.getPrefix(), m_edit, dnp.getSiteOverrides());
				}
			}

			// update the edit and release it
			m_preferencesService.commit(m_edit);
		}
		processRegisteredNotificationItems();
		notiUpdated = true;
		return "noti";
	}

	/**
	 * process notification cancel
	 * 
	 * @return navigation outcome to notification page
	 */
	public String processActionNotiCancel()
	{
		LOG.debug("processActionNotiCancel()");
		initRegisteredNotificationItems();
		return "noti";
	}

	/**
	 * Process the save command from the edit view.
	 * 
	 * @return navigation outcome to timezone page
	 */
	public String processActionTzSave()
	{
		setUserEditingOn();
		ResourcePropertiesEdit props = m_edit.getPropertiesEdit(TimeService.APPLICATION_ID);
		props.addProperty(TimeService.TIMEZONE_KEY, m_timeZone.getID());
		m_preferencesService.commit(m_edit);

		TimeService.clearLocalTimeZone(getUserId()); // clear user's cached timezone

		tzUpdated = true; // set for display of text massage
		return "timezone";
	}

	/**
	 * process timezone cancel
	 * 
	 * @return navigation outcome to timezone page
	 */
	public String processActionTzCancel()
	{
		LOG.debug("processActionTzCancel()");

		// restore original time zone
		m_timeZone = null;
		getSelectedTimeZone();

		return "timezone";
	}

	/**
	 * Process the save command from the edit view.
	 * 
	 * @return navigation outcome to locale page
	 */
	public String processActionLocSave()
	{
		setUserEditingOn();
		ResourcePropertiesEdit props = m_edit.getPropertiesEdit(ResourceLoader.APPLICATION_ID);
		props.addProperty(ResourceLoader.LOCALE_KEY, m_locale.toString());
		m_preferencesService.commit(m_edit);

		TimeService.clearLocalTimeZone(getUserId()); // clear user's cached timezone

		//Save the preference in the session also      
		ResourceLoader rl = new ResourceLoader();
		Locale loc = rl.setContextLocale(null);		

		// reset notification items with the locale
		initRegisteredNotificationItems();

		locUpdated = true; // set for display of text massage
		return "locale";
	}

	/**
	 * process locale cancel
	 * 
	 * @return navigation outcome to locale page
	 */
	public String processActionLocCancel()
	{
		LOG.debug("processActionLocCancel()");

		// restore original locale
		m_locale = null;
		getSelectedLocale();

		return "locale";
	}

	/**
	 * This is called from notification page for navigation to Refresh page
	 * 
	 * @return navigation outcome to refresh page
	 */
	public String processActionRefreshFrmNoti()
	{
		LOG.debug("processActionRefreshFrmNoti()");

		loadRefreshData();
		return "refresh";
	}

	// ////////////////////////////////////// HELPER METHODS FOR NOTIFICATIONS /////////////////////////////////////

	/**
	 * Read the two context references for defaults for this type from the form.
	 * 
	 * @param type
	 *        The resource type (i.e. a service name).
	 * @param prefix
	 *        The prefix for context references.
	 * @param edit
	 *        The preferences being edited.
	 * @param data
	 *        The rundata with the form fields.
	 */
	protected void readTypePrefs(String type, String prefix, PreferencesEdit edit, String data)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("readTypePrefs(String " + type + ", String " + prefix + ", PreferencesEdit " + edit + ", String " + data
					+ ")");
		}

		// update the default settings from the form
		ResourcePropertiesEdit props = edit.getPropertiesEdit(NotificationService.PREFS_TYPE + type);

		// read the defaults
		props.addProperty(Integer.toString(NotificationService.NOTI_OPTIONAL), data);

	} // readTypePrefs
	
	/**
	 * Read the two context references for defaults for this type from the form.
	 * 
	 * @param type
	 *        The resource type (i.e. a service name).
	 * @param prefix
	 *        The prefix for context references.
	 * @param edit
	 *        The preferences being edited.
	 * @param data
	 *        The rundata with the form fields.
	 */
	protected void readOverrideTypePrefs(String type, String prefix, PreferencesEdit edit, List<SiteOverrideBean> data)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("readOverrideTypePrefs(String " + type + ", String " + prefix + ", PreferencesEdit " + edit + ", String " + data
					+ ")");
		}
		
		List<SiteOverrideBean> toDel = new ArrayList<SiteOverrideBean>();

		// update the default settings from the form
		ResourcePropertiesEdit props = edit.getPropertiesEdit(NotificationService.PREFS_TYPE + type);

		// read the defaults
		for (SiteOverrideBean sob : data) {
			if (!sob.remove) {
				props.addProperty(sob.getSiteId(), sob.getOption());
			}
			else {
				props.removeProperty(sob.getSiteId());
				toDel.add(sob);
			}
		}
		data.removeAll(toDel);

	} // readOverrideTypePrefs
	
	/**
	 * Read the two context references for defaults for this type from the form.
	 * 
	 * @param type
	 *        The resource type (i.e. a service name).
	 * @param edit
	 *        The preferences being edited.
	 * @param data
	 *        The rundata with the form fields.
	 */
	protected void readOverrideTypePrefs(String type, PreferencesEdit edit, List<SiteOverrideBean> data)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("readOverrideTypePrefs(String " + type + ", PreferencesEdit " + edit + ", String " + data
					+ ")");
		}

		// update the default settings from the form
		ResourcePropertiesEdit props = edit.getPropertiesEdit(NotificationService.PREFS_TYPE + type);

		// read the defaults
		for (SiteOverrideBean sob : data) {
			props.addProperty(sob.getSiteId(), sob.getOption());
		}

	} // readOverrideTypePrefs
	
	/**
	 * delete the preferences for this type.
	 * 
	 * @param type
	 *        The resource type (i.e. a service name).
	 * @param prefix
	 *        The prefix for context references.
	 * @param edit
	 *        The preferences being edited.
	 * @param data
	 *        The rundata with the form fields.
	 */
	protected void deleteOverrideTypePrefs(String type, String prefix, PreferencesEdit edit, List<String> data)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("deleteOverrideTypePrefs(String " + type + ", String " + prefix + ", PreferencesEdit " + edit + ", String " + data
					+ ")");
		}

		ResourcePropertiesEdit props = edit.getPropertiesEdit(NotificationService.PREFS_TYPE + type);

		// delete
		for (String siteId : data) {
			props.removeProperty(siteId);
		}

	} // deleteOverrideTypePrefs

	/**
	 * Add the two context references for defaults for this type.
	 * 
	 * @param type
	 *        The resource type (i.e. a service name).
	 * @param prefix
	 *        The prefix for context references.
	 * @param context
	 *        The context.
	 * @param prefs
	 *        The full set of preferences.
	 */
	protected String buildTypePrefsContext(String type, String prefix, String context, Preferences prefs)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("buildTypePrefsContext(String " + type + ", String " + prefix + ", String " + context + ", Preferences "
					+ prefs + ")");
		}

		ResourceProperties props = prefs.getProperties(NotificationService.PREFS_TYPE + type);
		String value = props.getProperty(new Integer(NotificationService.NOTI_OPTIONAL).toString());

		return value;
	}
	
	/**
	 * Add the two context references for defaults for this type.
	 * 
	 * @param type
	 *        The resource type (i.e. a service name).
	 * @param prefix
	 *        The prefix for context references.
	 * @param context
	 *        The context.
	 * @param prefs
	 *        The full set of preferences.
	 */
	protected List<SiteOverrideBean> buildOverrideTypePrefsContext(String type, String prefix, String context, Preferences prefs)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("buildOverrideTypePrefsContext(String " + type + ", String " + prefix + ", String " + context + ", Preferences "
					+ prefs + ")");
		}

		ResourceProperties props = prefs.getProperties(NotificationService.PREFS_TYPE + type);
		
		List<SiteOverrideBean> result = new ArrayList<SiteOverrideBean>();
		
		for (Iterator<String> i = props.getPropertyNames(); i.hasNext();) {
			String propName = i.next();
			SiteOverrideBean sob = new SiteOverrideBean(propName, props.getProperty(propName));
			result.add(sob);
		}
		
		Collections.sort(result, new SiteOverrideBeanSorter());
		
		return result;
	}

	// SAK-23895
	private String selectedTabLabel = "";


	private String getPrefTabLabel(){
	    if ( prefTabLabel != null )
	        return prefTabLabel;

	    Preferences prefs = (PreferencesEdit) m_preferencesService.getPreferences(getUserId());
	    ResourceProperties props = prefs.getProperties(CHARON_PREFS);
	    prefTabLabel = props.getProperty("tab:label");

	    if ( prefTabLabel == null )
	        prefTabLabel = String.valueOf(DEFAULT_TAB_LABEL);

	    return prefTabLabel;
	}
	/**
	 * @return Returns the getSelectedTabLabel.
	 */
	public String getSelectedTabLabel()
	{
	    this.selectedTabLabel= getPrefTabLabel();
	    return this.selectedTabLabel;

	}

	/**
	 * @param label
	 *        The tab label to set.
	 */
	public void setSelectedTabLabel(String label)
	{
	    this.prefTabLabel = label;
	    this.selectedTabLabel = label;
	}


	// ////////////////////////////////////// REFRESH //////////////////////////////////////////
	private String selectedRefreshItem = "";

	protected boolean refreshUpdated = false;

	/**
	 * @return Returns the selectedRefreshItem.
	 */
	public String getSelectedRefreshItem()
	{
		return selectedRefreshItem;
	}

	/**
	 * @param selectedRefreshItem
	 *        The selectedRefreshItem to set.
	 */
	public void setSelectedRefreshItem(String selectedRefreshItem)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setSelectedRefreshItem(String " + selectedRefreshItem + ")");
		}

		this.selectedRefreshItem = selectedRefreshItem;
	}

	// /**
	// * process saving of refresh
	// *
	// * @return navigation outcome to refresh page
	// */
	// public String processActionRefreshSave()
	// {
	// LOG.debug("processActionRefreshSave()");
	//
	// // get an edit
	// setUserEditingOn();
	// if (m_edit != null)
	// {
	// setStringPref(PortalService.SERVICE_NAME, "refresh", m_edit, getSelectedRefreshItem());
	// // update the edit and release it
	// m_preferencesService.commit(m_edit);
	// }
	// refreshUpdated = true;
	// return "refresh";
	// }

	/**
	 * Process cancel and navigate to list page.
	 * 
	 * @return navigation outcome to refresh page
	 */
	public String processActionRefreshCancel()
	{
		LOG.debug("processActionRefreshCancel()");

		loadRefreshData();
		return "refresh";
	}

	/**
	 * Process cancel and navigate to list page.
	 * 
	 * @return navigation outcome to notification page
	 */
	public String processActionNotiFrmRefresh()
	{
		LOG.debug("processActionNotiFrmRefresh()");

		return "noti";
		//return "tab";
	}

	// ///////////////////////////////////// HELPER METHODS FOR REFRESH /////////////////////////
	/**
	 * Load refresh data from stored information. This is called when navigated into this page for first time.
	 */
	protected void loadRefreshData()
	{
		LOG.debug("loadRefreshData()");

		selectedRefreshItem = "";
		refreshUpdated = false;
		if (!hasValue(selectedRefreshItem))
		{
			Preferences prefs = (PreferencesEdit) m_preferencesService.getPreferences(getUserId());
			// String a = getStringPref(PortalService.SERVICE_NAME, "refresh", prefs);
			// if (hasValue(a))
			// {
			// setSelectedRefreshItem(a); // load from saved data
			// }
			// else
			// {
			// setSelectedRefreshItem("2"); // default setting
			// }
		}
	}

	/**
	 * Set an integer preference.
	 * 
	 * @param pres_base
	 *        The name of the group of properties (i.e. a service name)
	 * @param type
	 *        The particular property
	 * @param edit
	 *        An edit version of the full set of preferences for the current logged in user.
	 * @param newval
	 *        The string to be the new preference.
	 */
	protected void setStringPref(String pref_base, String type, PreferencesEdit edit, String newval)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("setStringPref(String " + pref_base + ", String " + type + ", PreferencesEdit " + edit + ", String " + newval
					+ ")");
		}

		ResourcePropertiesEdit props = edit.getPropertiesEdit(pref_base);

		props.addProperty(type, newval);
	} // setStringPref

	/**
	 * Retrieve a preference
	 * 
	 * @param pres_base
	 *        The name of the group of properties (i.e. a service name)
	 * @param type
	 *        The particular property
	 * @param prefs
	 *        The full set of preferences for the current logged in user.
	 */
	protected String getStringPref(String pref_base, String type, Preferences prefs)
	{
		if (LOG.isDebugEnabled())
		{
			LOG.debug("getStringPref(String " + pref_base + ", String " + type + ", PreferencesEdit " + prefs + ")");
		}

		ResourceProperties props = prefs.getProperties(pref_base);
		String a = props.getProperty(type);
		return a;
	} // getIntegerPref

	/** Should we reload the top window? */
	protected Boolean m_reloadTop = Boolean.FALSE;

	/**
	 * Get, and clear, the reload element
	 */
	public Boolean getReloadTop()
	{
		Boolean rv = m_reloadTop;
		m_reloadTop = Boolean.FALSE;
		return rv;
	}

	public void setReloadTop(Boolean val) { }

	/**
	 * Pull whether privacy status should be enabled from sakai.properties
	 */
	public boolean isPrivacyEnabled()
	{
		//return ServerConfigurationService.getBoolean(ENABLE_PRIVACY_STATUS, false);
		if (getPrivacy_selection()==0){
			return false;
		}
		else {
			return true;
		}
		
	}

	/**
	 * Should research/collab specific preferences (no syllabus) be displayed?
	 * 
	 */
	public boolean isResearchCollab()
	{
		return ServerConfigurationService.getBoolean(PREFS_RESEARCH, false);
	}
	
	public List<DecoratedNotificationPreference> getRegisteredNotificationItems() {
		LOG.debug("getRegisteredNotificationItems()");
		return m_registereddNotificationItems;
	}
	
	public void initRegisteredNotificationItems() {
		LOG.debug("initRegisteredNotificationItems()");
		m_registereddNotificationItems.clear();
		for (UserNotificationPreferencesRegistration upr : m_userNotificationPreferencesRegistrationService.getRegisteredItems()) {

			m_registereddNotificationItems.addAll(getRegisteredNotificationItems(upr));
		}
		
		processRegisteredNotificationItems();
	}
	
	/**
	 * Convenience method to take a string array and put it in a map
	 * The key is the value in the array and the data in the map is the position in the array
	 * @param array
	 * @return
	 */
	private Map<String, Integer> stringArrayToMap(String[] array) {
		Map<String, Integer> retMap = new HashMap<String, Integer>();
		Integer index = 0;
		if (array != null) {
		    for (String key : array) {
			retMap.put(key, index);
			index++;
		    }
		}
		return retMap;
	}
	
	/**
	 * Convenience method to take a string (comma delimited list of values) and turn it in to a list.
	 * @param toolIds
	 * @return
	 */
	private List<String> stringToList(String toolIds)
	{
		if ((toolIds != null) && (toolIds.length() > 0))
		{
			String[] items = toolIds.split(",");
			return Arrays.asList(items);
		}
		return new ArrayList<String>();
	}
	
	/**
	 * Looks at the various hide and stealth properties to determine which tools should be displayed.
	 * This method mostly taken from org.sakaiproject.tool.impl.ToolComponent.init() and modified a bit.
	 * @return
	 */
	private String[] getHiddenTools() {
		// compute the tools to hide: these are the stealth tools plus the hidden tools, minus the visible ones
		Set<String> toHide = new HashSet();
		
		String hiddenToolsPrefs = ServerConfigurationService.getString("prefs.tool.hidden");
		String stealthTools = ServerConfigurationService.getString("stealthTools@org.sakaiproject.tool.api.ActiveToolManager");
		String hiddenTools = ServerConfigurationService.getString("hiddenTools@org.sakaiproject.tool.api.ActiveToolManager");
		String visibleTools = ServerConfigurationService.getString("visibleTools@org.sakaiproject.tool.api.ActiveToolManager");
		

		if (stealthTools != null)
		{
			toHide.addAll(stringToList(stealthTools));
		}

		if (hiddenTools!= null)
		{
			toHide.addAll(stringToList(hiddenTools));
		}

		if (visibleTools != null)
		{
			toHide.removeAll(stringToList(visibleTools));
		}
		
		if (hiddenToolsPrefs != null)
		{
			toHide.addAll(stringToList(hiddenToolsPrefs));
		}
		
		return toHide.toArray(new String[]{});

	}
	
	/**
	 * Determine the sorting and if any should be hidden from view
	 * @param decoItems
	 */
	private void processRegisteredNotificationItems() {
		
		Map<String, Integer> toolOrderMap = new HashMap<String, Integer>();
		String[] toolOrder = ServerConfigurationService.getStrings("prefs.tool.order");
		//String hiddenTools = ServerConfigurationService.getString("prefs.tool.hidden");
		
		String[] parsedHidden = getHiddenTools();
		Map<String, Integer> hiddenToolMap = new HashMap<String, Integer>();
		
		toolOrderMap = stringArrayToMap(toolOrder);
		hiddenToolMap = stringArrayToMap(parsedHidden);
		
		Preferences prefs = m_preferencesService.getPreferences(getUserId());
		
		for (DecoratedNotificationPreference dnp : m_registereddNotificationItems) {
			String toolId = dnp.getUserNotificationPreferencesRegistration().getToolId();
			Integer sort = toolOrderMap.get(toolId);
			if (sort != null)
				dnp.setSortOrder(sort);
			if (hiddenToolMap.get(toolId) != null) {
				dnp.setHidden(true);
			}
			
			ResourceProperties expandProps = prefs.getProperties(PREFS_EXPAND);
			if (expandProps != null) {
				String expandProp = expandProps.getProperty(dnp.key);
				if (expandProp != null) {
					boolean overrideExpand = expandProp.equalsIgnoreCase(PREFS_EXPAND_TRUE) ? true : false;
					dnp.setExpandOverride(overrideExpand);
				}
			}
		}
		Collections.sort(m_registereddNotificationItems, new DecoratedNotificationPreferenceSorter());
	}
	
	/**
	 * Get the current preference settings for this registration item
	 * @param upr
	 * @return
	 */
	public List<DecoratedNotificationPreference> getRegisteredNotificationItems(UserNotificationPreferencesRegistration upr) {
		LOG.debug("getRegisteredNotificationItems(UserNotificationPreferencesRegistration)");
		List<DecoratedNotificationPreference> selNotiItems = new ArrayList<DecoratedNotificationPreference>();
		Preferences prefs = m_preferencesService.getPreferences(getUserId());
		List<SiteOverrideBean> siteOverrides = new ArrayList<SiteOverrideBean>();
		if (upr.isOverrideBySite()) {
			siteOverrides = 
				buildOverrideTypePrefsContext(upr.getType() + NotificationService.NOTI_OVERRIDE_EXTENSION, 
						upr.getPrefix(), null, prefs);
		}
		DecoratedNotificationPreference dnp = new DecoratedNotificationPreference(upr, siteOverrides);
			String regItem = buildTypePrefsContext(upr.getType(), upr.getPrefix(), dnp.getSelectedOption(), prefs);
			if (hasValue(regItem))
			{
				dnp.setSelectedOption(regItem); // load from saved data
			}
			else
			{
				dnp.setSelectedOption(upr.getDefaultValue()); // default setting
			}
			
			selNotiItems.add(dnp);
		return selNotiItems;
	}
		
	public List<String> getSelectedNotificationItemIds(DecoratedNotificationPreference dnp) {
		LOG.debug("getSelectedNotificationItemIds(DecoratedNotificationPreference)");
		List<String> result = new ArrayList<String>();
		for (SiteOverrideBean sob : dnp.getSiteOverrides()) {
				result.add(sob.siteId);
		}
		return result;
	}

	public void setCurrentDecoratedNotificationPreference(
			DecoratedNotificationPreference currentDecoratedNotificationPreference) {
		this.currentDecoratedNotificationPreference = currentDecoratedNotificationPreference;
	}

	public DecoratedNotificationPreference getCurrentDecoratedNotificationPreference() {
		return currentDecoratedNotificationPreference;
	}

	private DecoratedNotificationPreference getDecoItemByKey(String key, List<DecoratedNotificationPreference> decoPreferences) {
		LOG.debug("getDecoItemByKey(" + key + ")");
		for (DecoratedNotificationPreference dnp : decoPreferences) {
			if (dnp.getKey().equalsIgnoreCase(key)) {
				return dnp;
			}
		}
		return null;
	}
	private String getSelectedNotificationItemByKey(String key, List<DecoratedNotificationPreference> decoPreferences) {
		LOG.debug("getSelectedNotificationItemByKey(" + key + ")");
		DecoratedNotificationPreference dnp = getDecoItemByKey(key, decoPreferences);
		if (dnp != null) {
			return dnp.getSelectedOption();
		}
		return null;
	}
	
	/**
	 * Get the display name for the site type in question.  
	 * If a course site, it will pull the info from the "term" site property
	 * @param site
	 * @return
	 */
	private String getSiteTypeDisplay(Site site) {
		ResourceProperties siteProperties = site.getProperties();

		String type = site.getType();
		String term = null;

		if ("course".equals(type))
		{
			term = siteProperties.getProperty("term");
		}
		else if ("project".equals(type))
		{
			term = msgs.getString("moresite_projects");
		}
		else if ("portfolio".equals(type))
		{
			term = msgs.getString("moresite_portfolios");
		}
		else if ("scs".equals(type))
		{
			term = msgs.getString("moresite_scs");
		}
		else if ("admin".equals(type))
		{
			term = msgs.getString("moresite_administration");
		}
		else
		{
			term = msgs.getString("moresite_other");
		}
		return term;
	}
	
	public class DecoratedNotificationPreference {
		
		private String key = "";
		private UserNotificationPreferencesRegistration userNotificationPreferencesRegistration = null;
		private String selectedOption = "";
		private List<SelectItem> optionSelectItems = new ArrayList<SelectItem>();
		private List<SiteOverrideBean> siteOverrides = new ArrayList<SiteOverrideBean>();
		private List<DecoratedSiteTypeBean> siteList = new ArrayList<DecoratedSiteTypeBean>();
		private Integer sortOrder = Integer.MAX_VALUE;
		private boolean hidden = false;
		private Boolean expandOverride = null;
		
		public DecoratedNotificationPreference() { 
			LOG.debug("DecoratedNotificationPreference()");
		}
		
		public DecoratedNotificationPreference(UserNotificationPreferencesRegistration userNotificationPreferencesRegistration, List<SiteOverrideBean> siteOverrides) {
			LOG.debug("DecoratedNotificationPreference(...)");
			this.userNotificationPreferencesRegistration = userNotificationPreferencesRegistration;
			this.key = userNotificationPreferencesRegistration.getType();
			this.siteOverrides = siteOverrides;
			
			for (String optionKey : userNotificationPreferencesRegistration.getOptions().keySet()) {
				SelectItem si = new SelectItem(optionKey, userNotificationPreferencesRegistration.getOptions().get(optionKey));
				optionSelectItems.add(si);
			}
		}

		public void setKey(String key) {
			this.key = key;
		}

		public String getKey() {
			return key;
		}

		public void setUserNotificationPreferencesRegistration(UserNotificationPreferencesRegistration userNotificationPreferencesRegistration) {
			this.userNotificationPreferencesRegistration = userNotificationPreferencesRegistration;
		}

		public UserNotificationPreferencesRegistration getUserNotificationPreferencesRegistration() {
			return userNotificationPreferencesRegistration;
		}

		public void setSelectedOption(String selectedOption) {
			this.selectedOption = selectedOption;
		}

		public String getSelectedOption() {
			return selectedOption;
		}

		public void setOptionSelectItems(List<SelectItem> optionSelectItems) {
			this.optionSelectItems = optionSelectItems;
		}

		public List<SelectItem> getOptionSelectItems() {
			return optionSelectItems;
		}

		public void setSiteOverrides(List<SiteOverrideBean> siteOverrides) {
			this.siteOverrides = siteOverrides;
		}

		public List<SiteOverrideBean> getSiteOverrides() {
			return siteOverrides;
		}
		
		public List<DecoratedSiteTypeBean> getSiteList() {
			return siteList;
		}

		public void setSiteList(List<DecoratedSiteTypeBean> siteList) {
			this.siteList = siteList;
		}

		public Integer getSortOrder() {
			return sortOrder;
		}

		public void setSortOrder(Integer sortOrder) {
			this.sortOrder = sortOrder;
		}

		public boolean isHidden() {
			return hidden;
		}

		public void setHidden(boolean hidden) {
			this.hidden = hidden;
		}
		
		public Boolean getExpandOverride() {
			return expandOverride;
		}

		public void setExpandOverride(Boolean expandOverride) {
			this.expandOverride = expandOverride;
		}
		
		public boolean getExpand() {
			Boolean override = getExpandOverride();
			if (override != null)
				return override;
			else
				return this.getUserNotificationPreferencesRegistration().isExpandByDefault();
		}

		public String processActionAddOverrides() {
			setCurrentDecoratedNotificationPreference(this);
			initSiteList();
			return "noti_addSiteOverride";
		}
		
		/**
		 * Initializing the site structures
		 */
		private void initSiteList() {
			Map<String, List<DecoratedSiteBean>> siteTypeMap = new HashMap<String, List<DecoratedSiteBean>>();
			Map<String, String> siteTypeKeyMap = new HashMap<String, String>();
			
			List<String> selectedSites = getSelectedNotificationItemIds(this);
			for (Site site : m_sites) {
				if (site.getToolForCommonId(userNotificationPreferencesRegistration.getToolId()) != null) {
					String typeDisplay = getSiteTypeDisplay(site);
					List<DecoratedSiteBean> sitesList = siteTypeMap.get(typeDisplay);
					if (sitesList == null) {
						sitesList = new ArrayList<DecoratedSiteBean>();
					}
					boolean selected = selectedSites.contains(site.getId());
					sitesList.add(new DecoratedSiteBean(site, selected));
					siteTypeMap.put(typeDisplay, sitesList);
					siteTypeKeyMap.put(typeDisplay, site.getType());
				}
			}
			
			String expandTypeString = ServerConfigurationService.getString("prefs.type.autoExpanded", "portfolio");
			
			String[] sortedTypeList = ServerConfigurationService.getStrings("prefs.type.order");
            if(sortedTypeList == null) {
                sortedTypeList = new String[] {"portfolio","course","project"};
            }
			String[] termOrder = ServerConfigurationService.getStrings("portal.term.order");
			List<String> myTermOrder = new ArrayList<String>();
					
			
			if (termOrder != null)
			{
				for (int i = 0; i < termOrder.length; i++)
				{

					if (siteTypeMap.containsKey(termOrder[i]))
					{
						myTermOrder.add(termOrder[i]);
					}
				}
			}

			int count = 0;
			for (int i = 0; i < sortedTypeList.length; i++) {
				
				if ("course".equalsIgnoreCase(sortedTypeList[i])) {
					boolean firstCourse = true;
					for (String value : myTermOrder) {
						if (value != null && !value.equals("")) {
							m_sortedTypes.put(value, count);
							count++;
							if (firstCourse) {
								expandTypeString = expandTypeString.concat("," + value);
								firstCourse=false;
							}
						}
					}
				}
				else {
					String value = sortedTypeList[i];
					if (value != null && !value.equals("")) {
						m_sortedTypes.put(value, count);
						count++;
					}
				}
			}
			//List<DecoratedSiteTypeBean> siteOverrideList = new ArrayList<DecoratedSiteTypeBean>();
			List<String> expandedTypes = Arrays.asList(expandTypeString.split(","));
			siteList = getFullSiteOverrideList(siteTypeMap, siteTypeKeyMap, expandedTypes);
		}
		
		/**
		 * Get all the sites by type and determine if the div should be expanded.
		 * @return
		 */
		private List<DecoratedSiteTypeBean> getFullSiteOverrideList(Map<String, List<DecoratedSiteBean>> siteTypeMap, 
				Map<String, String> siteTypeKeyMap, List<String> expandedTypes) {
			LOG.debug("getFullSiteOverrideList()");
			List<DecoratedSiteTypeBean> list = new ArrayList<DecoratedSiteTypeBean>();
			
			for (String keyText : siteTypeMap.keySet()) {
				boolean expand = false;
				String typeKey = siteTypeKeyMap.get(keyText);
				if (expandedTypes.contains(typeKey) || expandedTypes.contains(keyText.toUpperCase()))
					expand = true;
				
				list.add(new DecoratedSiteTypeBean(typeKey, keyText, siteTypeMap.get(keyText), expand));
			}
			
			Collections.sort(list, new SiteTypeSorter());
			
			return list;
		}
		
		/**
		 * Do the save action
		 * @return
		 */
		public String processActionSiteOverrideSave() {
			LOG.debug("processActionSiteOverrideSave()");
			
			// get an edit
			setUserEditingOn();
			if (m_edit != null)
			{
				List<SiteOverrideBean> toAdd = new ArrayList<SiteOverrideBean>();
				List<String> toDel = new ArrayList<String>();
				
				/** previously saved choices */
				List<String> existingList = convertToStringList(getSiteOverrides());
				
				LOG.debug("processActionSiteOverrideSave().existingList: " + convertListToString(existingList));
				
				for (DecoratedSiteTypeBean dstb : siteList) {
					for (DecoratedSiteBean dsb : dstb.getSites()) {
						String siteId = dsb.getSite().getId();
						LOG.debug("processActionSiteOverrideSave().selected?: " +siteId + ": " + dsb.selected);
						SiteOverrideBean sob = new SiteOverrideBean(siteId, Integer.toString(NotificationService.PREF_NONE));
						if (dsb.selected && !existingList.contains(siteId)) {
							toAdd.add(sob);
							//siteOverrides.add(sob);
						}
						else if (!dsb.selected && existingList.contains(siteId)) {
							toDel.add(siteId);
							//siteOverrides.remove(sob);
						}
					}
				}

				LOG.debug("processActionSiteOverrideSave().toAdd: " + convertListToString(toAdd));
				LOG.debug("processActionSiteOverrideSave().toDel: " + convertListToString(toDel));
				//adds
				readOverrideTypePrefs(userNotificationPreferencesRegistration.getType() + NotificationService.NOTI_OVERRIDE_EXTENSION, 
						m_edit, toAdd);

				//deletes
				deleteOverrideTypePrefs(userNotificationPreferencesRegistration.getType() + NotificationService.NOTI_OVERRIDE_EXTENSION, 
						userNotificationPreferencesRegistration.getPrefix(), m_edit, toDel);

				// update the edit and release it
				m_preferencesService.commit(m_edit);
				
				//make sure the list gets updated
				initRegisteredNotificationItems();
			}
			
			notiUpdated = true;
			return "noti";
		}
		
		/**
		 * For display/debug purposes.  Turns a List into a readable string
		 * @param list
		 * @return
		 */
		private String convertListToString(List list) {
			String retVal = "[";
			int counter = 0;
			for (Iterator i = list.iterator(); i.hasNext();) {
				
				Object rawValue = i.next();
				String val = "";
				if (rawValue instanceof SiteOverrideBean) {
					val = ((SiteOverrideBean)rawValue).getSiteId();
				}
				else {
					val = (String) rawValue;
				}
				
				if (counter > 0) 
					retVal = retVal.concat(",");
				retVal = retVal.concat(val);
				counter++;
			}
			return retVal.concat("]");
		}
		
		/**
		 * For display/debug purposes.  Turns a List of SiteOverrideBeans into a readable string
		 * @param list
		 * @return
		 */
		private List<String> convertToStringList(List<SiteOverrideBean> list) {
			List<String> retList = new ArrayList<String>(list.size());
			for (SiteOverrideBean sob : list) {
				retList.add(sob.getSiteId());
			}
			return retList;
		}
		
		/**
		 * Do the cancel action
		 * @return
		 */
		public String processActionSiteOverrideCancel() {
			LOG.debug("processActionSiteOverrideCancel()");
			processRegisteredNotificationItems();
			return "noti";
		}
	}
		
	public class SiteOverrideBean {
		
		private String siteId = "";
		private String siteTitle = "";
		private String option = "";
		private boolean remove = false;
		
		public SiteOverrideBean() {
			LOG.debug("SiteOverrideBean()");
		}
		
		public SiteOverrideBean(String siteId, String option) {
			LOG.debug("SiteOverrideBean(String, String)");
			this.siteId = siteId;
			this.option = option;
			
			try {
				Site site = SiteService.getSite(siteId);
				this.siteTitle =site.getTitle();
			} catch (IdUnusedException e) {
				LOG.warn("Unable to get Site object for id: " + siteId, e);
			}
		}
		
		public String getSiteId() {
			return siteId;
		}
		public void setSiteId(String siteId) {
			this.siteId = siteId;
		}
		public String getSiteTitle() {
			return siteTitle;
		}
		public void setSiteTitle(String siteTitle) {
			this.siteTitle = siteTitle;
		}
		public String getOption() {
			return option;
		}
		public void setOption(String option) {
			this.option = option;
		}

		public void setRemove(boolean remove) {
			this.remove = remove;
		}

		public boolean isRemove() {
			return remove;
		}
	}
	
	public class DecoratedSiteTypeBean {
		private String typeKey = "";
		private String typeText = "";
		private String condensedTypeText = "";
		private List<DecoratedSiteBean> sites = new ArrayList<DecoratedSiteBean>();
		private List<SelectItem> sitesAsSelects = new ArrayList<SelectItem>();
		private boolean defaultOpen = false;
		
		public DecoratedSiteTypeBean() {
			LOG.debug("DecoratedSiteTypeBean()");
		}
		
		public DecoratedSiteTypeBean(String typeKey, String typeText, List<DecoratedSiteBean> sites, boolean defaultOpen) {
			LOG.debug("DecoratedSiteTypeBean(...)");
			this.setTypeKey(typeKey);
			this.typeText = typeText;
			this.sites = sites;
			this.condensedTypeText = typeText.replace(" ", "");
			this.defaultOpen = defaultOpen;
			
			for (DecoratedSiteBean dsb : sites) {
				sitesAsSelects.add(new SelectItem(dsb.getSite().getId(), dsb.getSite().getTitle()));
			}			
		}
		
		public String getStyle() {
			String style = "display: none;";
			if (defaultOpen)
				style = "display: block;";
			return style;
		}
		
		public String getIconUrl() {
			String url = "/library/image/sakai/expand.gif";
			if (defaultOpen)
				url = "/library/image/sakai/collapse.gif";
			return url;
		}
		
		public String getShowHideText() {
			String key = "hideshowdesc_toggle_show";
			if (defaultOpen)
				key = "hideshowdesc_toggle_hide";
			return msgs.getString(key);
		}
		
		public Integer getSortOrder() {
			Integer sort = null;
			if (typeKey.equals("course")) {
				sort = m_sortedTypes.get(typeText.toUpperCase());
			}
			else {
				sort = m_sortedTypes.get(typeKey);
			}
			
			if (sort == null)
				sort = Integer.MAX_VALUE;
			
			return sort;
		}

		public void setTypeKey(String typeKey) {
			this.typeKey = typeKey;
		}

		public String getTypeKey() {
			return typeKey;
		}

		public String getTypeText() {
			return typeText;
		}

		public void setTypeText(String typeText) {
			this.typeText = typeText;
		}

		public String getCondensedTypeText() {
			return condensedTypeText;
		}

		public void setCondensedTypeText(String condensedTypeText) {
			this.condensedTypeText = condensedTypeText;
		}

		public List<DecoratedSiteBean> getSites() {
			return sites;
		}

		public void setSites(List<DecoratedSiteBean> sites) {
			this.sites = sites;
		}

		public List<SelectItem> getSitesAsSelects() {
			return sitesAsSelects;
		}

		public void setSitesAsSelects(List<SelectItem> sitesAsSelects) {
			this.sitesAsSelects = sitesAsSelects;
		}

		public void setDefaultOpen(boolean defaultOpen) {
			this.defaultOpen = defaultOpen;
		}

		public boolean isDefaultOpen() {
			return defaultOpen;
		}
	}
	
	public class DecoratedSiteBean {
		private Site site = null;
		private boolean selected = false;
		
		public DecoratedSiteBean() {
			LOG.debug("DecoratedSiteBean()");
		}
		
		public DecoratedSiteBean(Site site) {
			LOG.debug("DecoratedSiteBean(Site)");
			this.site = site;
		}
		
		public DecoratedSiteBean(Site site, boolean selected) {
			LOG.debug("DecoratedSiteBean(Site, boolean)");
			this.site = site;
			this.selected = selected;
		}

		public Site getSite() {
			return site;
		}

		public void setSite(Site site) {
			this.site = site;
		}

		public boolean isSelected() {
			return selected;
		}

		public void setSelected(boolean selected) {
			this.selected = selected;
		}
		
		public void checkBoxChanged(ValueChangeEvent vce) {
			LOG.debug("checkBoxChanged()" + site.getId() + ": " + vce.getOldValue().toString() + "-->" + vce.getNewValue().toString());
			Boolean tmpSelected = (Boolean)vce.getNewValue();
			if (tmpSelected != null) {
				selected = tmpSelected;
			}
		}
	}
	
	/**
	 * Class that figures out the order of the site types
	 * @author chrismaurer
	 *
	 */
	class SiteTypeSorter implements Comparator<DecoratedSiteTypeBean>
	{
		public int compare(DecoratedSiteTypeBean first, DecoratedSiteTypeBean second)
		{
			if (first == null || second == null) return 0;

			Integer firstSort = first.getSortOrder();
			Integer secondSort = second.getSortOrder();

			if (firstSort != null)
				return firstSort.compareTo(secondSort);

			return 0;
		}

	}
	
	/**
	 * Class that figures out the order of the site types
	 * @author chrismaurer
	 *
	 */
	class SiteOverrideBeanSorter implements Comparator<SiteOverrideBean>
	{
		public int compare(SiteOverrideBean first, SiteOverrideBean second)
		{
			if (first == null || second == null) return 0;

			String firstSort = first.getSiteTitle();
			String secondSort = second.getSiteTitle();

			if (firstSort != null)
				return firstSort.toLowerCase().compareTo(secondSort.toLowerCase());

			return 0;
		}

	}
	
	/**
	 * Class that figures out the order of the site types
	 * @author chrismaurer
	 *
	 */
	class DecoratedNotificationPreferenceSorter implements Comparator<DecoratedNotificationPreference>
	{
		public int compare(DecoratedNotificationPreference first, DecoratedNotificationPreference second)
		{
			if (first == null || second == null) return 0;

			Integer firstSort = first.getSortOrder();
			Integer secondSort = second.getSortOrder();

			if (firstSort != null)
				return firstSort.compareTo(secondSort);

			return 0;
		}

	}
	
}