001: /*
002: * Copyright (c) 2001 - 2005 ivata limited.
003: * All rights reserved.
004: * -----------------------------------------------------------------------------
005: * ivata groupware may be redistributed under the GNU General Public
006: * License as published by the Free Software Foundation;
007: * version 2 of the License.
008: *
009: * These programs are free software; you can redistribute them and/or
010: * modify them under the terms of the GNU General Public License
011: * as published by the Free Software Foundation; version 2 of the License.
012: *
013: * These programs are distributed in the hope that they will be useful,
014: * but WITHOUT ANY WARRANTY; without even the implied warranty of
015: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
016: *
017: * See the GNU General Public License in the file LICENSE.txt for more
018: * details.
019: *
020: * If you would like a copy of the GNU General Public License write to
021: *
022: * Free Software Foundation, Inc.
023: * 59 Temple Place - Suite 330
024: * Boston, MA 02111-1307, USA.
025: *
026: *
027: * To arrange commercial support and licensing, contact ivata at
028: * http://www.ivata.com/contact.jsp
029: * -----------------------------------------------------------------------------
030: * $Log: SettingsImpl.java,v $
031: * Revision 1.3 2005/10/03 10:21:15 colinmacleod
032: * Fixed some style and javadoc issues.
033: *
034: * Revision 1.2 2005/10/02 14:08:59 colinmacleod
035: * Added/improved log4j logging.
036: *
037: * Revision 1.1 2005/09/29 13:06:05 colinmacleod
038: * First version of setting subproject.
039: * Existing classes restructured, new setting user interface created.
040: * Flexible XML UI configuration makes it easy to reuse the same web pages in
041: * other projects.
042: * Web files work as stand-alone webapp for testing.
043: *
044: * Revision 1.5 2005/09/14 14:52:01 colinmacleod
045: * Added serialVersionUID.
046: *
047: * Revision 1.4 2005/04/22 09:19:17 colinmacleod
048: * Added better error handling (when
049: * value is null).
050: *
051: * Revision 1.3 2005/04/10 20:08:14 colinmacleod
052: * Added new themes.
053: * Changed id type to String.
054: * Changed i tag to em and b tag to strong.
055: * Improved PicoContainerFactory with NanoContainer scripts.
056: *
057: * Revision 1.2 2005/04/09 17:19:05 colinmacleod
058: * Changed copyright text to GPL v2 explicitly.
059: *
060: * Revision 1.1.1.1 2005/03/10 17:50:38 colinmacleod
061: * Restructured ivata op around Hibernate/PicoContainer.
062: * Renamed ivata groupware.
063: *
064: * Revision 1.5 2004/11/12 18:17:09 colinmacleod
065: * Ordered imports.
066: *
067: * Revision 1.4 2004/11/12 15:56:46 colinmacleod
068: * Removed dependencies on SSLEXT.
069: * Moved Persistence classes to ivata masks.
070: *
071: * Revision 1.3 2004/11/03 15:33:05 colinmacleod
072: * Cosmetic changes.
073: *
074: * Revision 1.2 2004/07/13 19:54:31 colinmacleod
075: * Moved project to POJOs from EJBs.
076: * Applied PicoContainer to services layer (replacing session EJBs).
077: * Applied Hibernate to persistence layer (replacing entity EJBs).
078: * -----------------------------------------------------------------------------
079: */
080: package com.ivata.groupware.admin.setting;
081:
082: import org.apache.log4j.Logger;
083:
084: import java.text.SimpleDateFormat;
085: import java.util.Arrays;
086: import java.util.Iterator;
087: import java.util.Locale;
088: import java.util.Map;
089: import java.util.ResourceBundle;
090:
091: import com.ivata.groupware.admin.security.server.SecuritySession;
092: import com.ivata.groupware.admin.security.user.UserDO;
093: import com.ivata.groupware.business.BusinessLogic;
094: import com.ivata.mask.persistence.FinderException;
095: import com.ivata.mask.persistence.PersistenceSession;
096: import com.ivata.mask.persistence.QueryPersistenceManager;
097: import com.ivata.mask.util.StringHandling;
098: import com.ivata.mask.util.SystemException;
099: import com.ivata.mask.validation.ValidationError;
100: import com.ivata.mask.validation.ValidationErrors;
101: import com.ivata.mask.validation.ValidationException;
102:
103: /**
104: * <p>This class controls/sets the global preferences.</p>
105: *
106: * @since 2001-09-06
107: * @author Colin MacLeod
108: * <a href='mailto:colin.macleod@ivata.com'>colin.macleod@ivata.com</a>
109: * @version $Revision: 1.3 $
110: */
111: public class SettingsImpl extends BusinessLogic implements Settings {
112: /**
113: * Logger for this class.
114: */
115: private static final Logger logger = Logger
116: .getLogger(SettingsImpl.class);
117:
118: /**
119: * Serialization version (for <code>Serializable</code> interface).
120: */
121: private static final long serialVersionUID = 1L;
122: /**
123: * Persistence manger used to store/retrieve data objects, or retrieve a
124: * new persistence session.
125: */
126: private QueryPersistenceManager persistenceManager;
127:
128: /**
129: * Construct a new settings object.
130: *
131: * @param persistenceManagerParam used to store objects in db.
132: */
133: public SettingsImpl(
134: final QueryPersistenceManager persistenceManagerParam) {
135: this .persistenceManager = persistenceManagerParam;
136: }
137:
138: /**
139: * <p>
140: * Change the value of an existing setting.
141: * </p>
142: *
143: * @param name The name of the setting to set.
144: * @param securitySession Used to authenticate the user.
145: * @param value The new value to be set.
146: * @param user if not <code>null</code>, then the setting for this user
147: * is set, otherwise the general setting is changed.
148: * @throws SystemException If there is a technical problem retrieving the
149: * setting.
150: */
151: public void amendSetting(final SecuritySession securitySession,
152: final String name, final Object value, final UserDO user)
153: throws SystemException {
154: if (logger.isDebugEnabled()) {
155: logger
156: .debug("amendSetting(SecuritySession securitySession = "
157: + securitySession
158: + ", String name = "
159: + name
160: + ", Object value = "
161: + value
162: + ", UserDO user = " + user + ") - start");
163: }
164:
165: PersistenceSession persistenceSession = persistenceManager
166: .openSession(securitySession);
167: try {
168: // type must be the same as the existing one
169: SettingDO generalSetting = (SettingDO) persistenceManager
170: .findInstance(persistenceSession,
171: "adminSettingByName", new Object[] { name });
172:
173: if ((generalSetting.getType() == SettingConstants.DATA_TYPE_INTEGER)
174: && !(value instanceof Integer)) {
175: throw new ValidationException(new ValidationError(
176: "errors.setting.type.integer", Arrays
177: .asList(new Object[] {
178: value.getClass().getName(),
179: value })));
180: } else if ((generalSetting.getType() == SettingConstants.DATA_TYPE_BOOLEAN)
181: && !(value instanceof Boolean)) {
182: new ValidationError("errors.setting.type.boolean",
183: Arrays.asList(new Object[] {
184: value.getClass().getName(), value }));
185: } else if (!(value instanceof String)) {
186: String className;
187: if (value == null) {
188: className = "[None]";
189: } else {
190: className = value.getClass().getName();
191: }
192: new ValidationError(
193: "errors.setting.type.string",
194: Arrays
195: .asList(new Object[] { className, value }));
196: }
197:
198: // if there is no user, change the general setting, otherwise find
199: // the user setting and change that
200: if (user == null) {
201: generalSetting.setValue(value.toString());
202: persistenceManager.amend(persistenceSession,
203: generalSetting);
204: } else {
205: try {
206: SettingDO setting = (SettingDO) persistenceManager
207: .findInstance(
208: persistenceSession,
209: "adminSettingByNameUserName",
210: new Object[] { name, user.getName() });
211: setting.setValue(StringHandling.getNotNull(value,
212: null));
213: } catch (FinderException e) {
214: if (logger.isDebugEnabled()) {
215: logger.debug("amendSetting(SecuritySession, "
216: + "String, Object, UserDO)", e);
217: }
218:
219: // create a new setting
220: SettingDO setting = new SettingDO();
221: setting.setEnabled(generalSetting.isEnabled());
222: setting.setName(name);
223: setting.setType(generalSetting.getType());
224: setting.setUser(user);
225: setting.setValue(value.toString());
226: persistenceManager.add(persistenceSession, setting);
227: }
228:
229: }
230: } catch (Exception e) {
231: logger
232: .error(
233: "amendSetting(SecuritySession, String, Object, UserDO)",
234: e);
235:
236: persistenceSession.cancel();
237: throw new SystemException(e);
238: } finally {
239: persistenceSession.close();
240: }
241:
242: if (logger.isDebugEnabled()) {
243: logger.debug("amendSetting(SecuritySession, String, "
244: + "Object, UserDO) - end");
245: }
246: }
247:
248: /**
249: * Find a setting with a given name for the user.
250: *
251: * @param securitySession Used to authenticate the user.
252: * @param name the name of the setting to find
253: * @param user the user who owns this setting, or <code>null</code> if the
254: * setting is shared by all users.
255: * @return The setting.
256: * @throws SystemException If the setting cannot be retrieved for any
257: * reason.
258: */
259: private SettingDO findSetting(
260: final SecuritySession securitySession, final String name,
261: final UserDO user) throws SystemException {
262: if (logger.isDebugEnabled()) {
263: logger
264: .debug("findSetting(SecuritySession securitySession = "
265: + securitySession
266: + ", String name = "
267: + name
268: + ", UserDO user = "
269: + user
270: + ") - start");
271: }
272:
273: PersistenceSession persistenceSession = persistenceManager
274: .openSession(securitySession);
275: try {
276:
277: SettingDO setting = null;
278:
279: // first try to find the user setting - if a user was specified
280: if ((user != null) && (user.getName() != null)) {
281: try {
282: setting = (SettingDO) persistenceManager
283: .findInstance(
284: persistenceSession,
285: "adminSettingByNameUserName",
286: new Object[] { name, user.getName() });
287: } catch (FinderException e) {
288: // ok - we will try to get the general setting
289: if (logger.isDebugEnabled()) {
290: logger
291: .error(
292: "findSetting(SecuritySession, String, UserDO)",
293: e);
294: }
295: }
296: }
297:
298: // if the setting is still null, try to find the general setting
299: if (setting == null) {
300: setting = (SettingDO) persistenceManager.findInstance(
301: persistenceSession, "adminSettingByName",
302: new Object[] { name });
303: }
304:
305: if (logger.isDebugEnabled()) {
306: logger
307: .debug("findSetting(SecuritySession, String, UserDO) - "
308: + "end - return value = " + setting);
309: }
310: return setting;
311: } catch (Exception e) {
312: logger.error(
313: "findSetting(SecuritySession, String, UserDO)", e);
314:
315: persistenceSession.cancel();
316: if (e instanceof SystemException) {
317: throw (SystemException) e;
318: }
319: throw new SystemException(e);
320: } finally {
321: persistenceSession.close();
322: }
323: }
324:
325: /**
326: * <p>Get a setting of class <code>Boolean</code>.</p>
327: *
328: * @param securitySession Used to authenticate the user.
329: * @param name the name of the setting to return the value for
330: * @param user The user to search for. If null is specified, the
331: * default setting is searched for and returned if found.
332: * @return A setting of class <code>Boolean</code> for the setting
333: * name provided.
334: * @see #getSetting
335: * @see #getIntegerSetting
336: * @see #getStringSetting
337: * @throws SystemException If this setting does not exist or there is a
338: * technical problem. Throws <code>SettingsDataTypeException</code>
339: * if the setting has any class other than <code>Boolean</code>.
340: */
341: public final Boolean getBooleanSetting(
342: final SecuritySession securitySession, final String name,
343: final UserDO user) throws SystemException {
344: if (logger.isDebugEnabled()) {
345: logger.debug("getBooleanSetting(SecuritySession session = "
346: + securitySession + ", String name = " + name
347: + ", UserDO user = " + user + ") - start");
348: }
349:
350: Boolean returnBoolean = (Boolean) getSettingOfType(
351: securitySession, name, user, Boolean.class);
352: if (logger.isDebugEnabled()) {
353: logger
354: .debug("getBooleanSetting(SecuritySession, String, UserDO) "
355: + "- end - return value = " + returnBoolean);
356: }
357: return returnBoolean;
358: }
359:
360: /**
361: * <p>Get a setting of class <code>Integer</code>.</p>
362: *
363: * @param securitySession Used to authenticate the user.
364: * @param name the name of the setting to return the value for.
365: * @param user The user to search for. If null is specified, the
366: * default setting is searched for and returned if found.
367: * @return A setting of class <code>Integer</code> for the setting
368: * name provided.
369: * @see #getSetting
370: * @see #getStringSetting
371: * @see #getBooleanSetting
372: * @throws SystemException If this setting does not exist or there is a
373: * technical problem. Throws <code>SettingsDataTypeException</code>
374: * if the setting has any class other than <code>Integer</code>.
375: */
376: public final Integer getIntegerSetting(
377: final SecuritySession securitySession, final String name,
378: final UserDO user) throws SystemException {
379: if (logger.isDebugEnabled()) {
380: logger.debug("getIntegerSetting(SecuritySession session = "
381: + securitySession + ", String name = " + name
382: + ", UserDO user = " + user + ") - start");
383: }
384:
385: Integer returnInteger = (Integer) getSettingOfType(
386: securitySession, name, user, Integer.class);
387: if (logger.isDebugEnabled()) {
388: logger
389: .debug("getIntegerSetting(SecuritySession, String, UserDO) "
390: + "- end - return value = " + returnInteger);
391: }
392: return returnInteger;
393: }
394:
395: /**
396: * <p>Get a setting for a given user. The class of the returned object will
397: * depend on the <code>type</code> field of the EJB with this name and can
398: * be one of:</br/>
399: * <ul>
400: * <li><code>Integer</code></li>
401: * <li><code>String</code></li>
402: * <li><code>Boolean</code></li>
403: * </ul></p>
404: *
405: * @param securitySession Used to authenticate the user.
406: * @param name The name of the setting to return the value for
407: * @param userDO The user to search for. If null is specified, the
408: * default setting is searched for and returned if found.
409: * @return A setting with the setting name provided. The type of the
410: * returned object depends on the <code>type</code> field of the
411: * setting.
412: * @see #getIntegerSetting
413: * @see #getStringSetting
414: * @see #getBooleanSetting
415: * @throws SystemException If this setting does not exist, or there is a
416: * technical problem retrieving it.
417: */
418: public final Object getSetting(
419: final SecuritySession securitySession, final String name,
420: final UserDO userDO) throws SystemException {
421: if (logger.isDebugEnabled()) {
422: logger
423: .debug("getSetting(SecuritySession securitySession = "
424: + securitySession
425: + ", String name = "
426: + name
427: + ", UserDO userDO = "
428: + userDO
429: + ") - start");
430: }
431:
432: SettingDO setting = findSetting(securitySession, name, userDO);
433: Object returnObject;
434: // set the type on the basis of the class of the parameter
435: switch (setting.getType()) {
436: case SettingConstants.DATA_TYPE_INTEGER:
437: returnObject = new Integer(setting.getValue());
438: break;
439:
440: case SettingConstants.DATA_TYPE_BOOLEAN:
441: returnObject = new Boolean(setting.getValue());
442: break;
443:
444: // make the default a string
445: default:
446: returnObject = setting.getValue();
447: break;
448: }
449:
450: if (logger.isDebugEnabled()) {
451: logger
452: .debug("getSetting(SecuritySession, String, UserDO) - "
453: + "end - return value = " + returnObject);
454: }
455: return returnObject;
456: }
457:
458: /**
459: * Private helper. Get a setting and check it has the type specified.
460: *
461: * @param securitySession Used to authenticate the user.
462: * @param name The name of the setting to return the value for
463: * @param user The user to search for. If null is specified, the
464: * default setting is searched for and returned if found.
465: * @param settingType Class of the setting. Can be <code>Boolean</code>,
466: * <code>Integer</code> or <code>String</code>. Must match the datastore
467: * value for this setting.
468: * @throws SystemException If this setting does not exist, or there is a
469: * technical problem retrieving it. (Throws
470: * <code>SettingsDataTypeException</code> If the stored setting is not
471: * appropriate for the class <code>settingType</code> provided.)
472: * @return Value of the setting requested.
473: */
474: private Object getSettingOfType(
475: final SecuritySession securitySession, final String name,
476: final UserDO user, final Class settingType)
477: throws SystemException {
478: if (logger.isDebugEnabled()) {
479: logger.debug("getSettingOfType(SecuritySession session = "
480: + securitySession + ", String name = " + name
481: + ", UserDO user = " + user
482: + ", Class settingType = " + settingType
483: + ") - start");
484: }
485:
486: Object oTest = getSetting(securitySession, name, user);
487: if ((oTest != null)
488: && (!oTest.getClass().getName().equals(
489: settingType.getName()))) {
490: throw new SettingsDataTypeException("Setting '" + name
491: + "' has class '" + oTest.getClass().getName()
492: + "', expected '" + settingType.getName() + "'.");
493: }
494:
495: if (logger.isDebugEnabled()) {
496: logger.debug("getSettingOfType(SecuritySession, String, "
497: + "UserDO, Class) - end - return value = " + oTest);
498: }
499: return oTest;
500: }
501:
502: /**
503: * <p>
504: * Get the type of a setting.
505: * </p>
506: * @param securitySession Used to authenticate the user.
507: * @param name the name of the setting
508: * @return one of the static fields of <code>SettingConstants</code>
509: * @throws SystemException if this setting does not exist.
510: */
511: public final int getSettingType(
512: final SecuritySession securitySession, final String name)
513: throws SystemException {
514: if (logger.isDebugEnabled()) {
515: logger
516: .debug("getSettingType(SecuritySession securitySession = "
517: + securitySession
518: + ", String name = "
519: + name + ") - start");
520: }
521:
522: PersistenceSession persistenceSession = persistenceManager
523: .openSession(securitySession);
524: try {
525: int returnInt = ((SettingDO) persistenceManager
526: .findInstance(persistenceSession,
527: "adminSettingByName", new Object[] { name }))
528: .getType();
529: if (logger.isDebugEnabled()) {
530: logger
531: .debug("getSettingType(SecuritySession, String) - "
532: + "end - return value = " + returnInt);
533: }
534: return returnInt;
535: } catch (Exception e) {
536: logger.error("getSettingType(SecuritySession, String)", e);
537:
538: persistenceSession.cancel();
539: throw new SystemException(e);
540: } finally {
541: persistenceSession.close();
542: }
543: }
544:
545: /**
546: * <p>Get a setting of class String.</p>
547: *
548: * @param securitySession Used to authenticate the user.
549: * @param name The name of the setting to return the value for
550: * @param user The user to search for. If null is specified, the
551: * default setting is searched for and returned if found.
552: * @return A setting of class <code>String</code> for the setting
553: * name provided.
554: * @see #getSetting
555: * @see #getIntegerSetting
556: * @see #getBooleanSetting
557: * @throws SystemException If this setting does not exist or there is a
558: * technical problem. Throws <code>SettingsDataTypeException</code>
559: * if the setting has any class other than <code>String</code>.
560: */
561: public final String getStringSetting(
562: final SecuritySession securitySession, final String name,
563: final UserDO user) throws SystemException {
564: if (logger.isDebugEnabled()) {
565: logger.debug("getStringSetting(SecuritySession session = "
566: + securitySession + ", String name = " + name
567: + ", UserDO user = " + user + ") - start");
568: }
569:
570: String returnString = (String) getSettingOfType(
571: securitySession, name, user, String.class);
572: if (logger.isDebugEnabled()) {
573: logger
574: .debug("getStringSetting(SecuritySession, String, UserDO) - "
575: + " end - return value = " + returnString);
576: }
577: return returnString;
578: }
579:
580: /**
581: * <p>
582: * Find out whether or not a setting is enabled.
583: * </p>
584: *
585: * @param securitySession Used to authenticate the user.
586: * @param name Name of the setting to check.
587: * @return <code>true</code> if the setting exists and is enabled.
588: * @throws SystemException If there is a technical problem checking the
589: * setting.
590: */
591: public boolean isSettingEnabled(
592: final SecuritySession securitySession, final String name)
593: throws SystemException {
594: if (logger.isDebugEnabled()) {
595: logger
596: .debug("isSettingEnabled(SecuritySession securitySession = "
597: + securitySession
598: + ", String name = "
599: + name + ") - start");
600: }
601:
602: PersistenceSession persistenceSession = persistenceManager
603: .openSession(securitySession);
604: try {
605: SettingDO setting = (SettingDO) persistenceManager
606: .findInstance(persistenceSession,
607: "adminSettingByName", new Object[] { name });
608: boolean returnboolean = setting.isEnabled();
609: if (logger.isDebugEnabled()) {
610: logger
611: .debug("isSettingEnabled(SecuritySession, String) - end "
612: + "- return value = " + returnboolean);
613: }
614: return returnboolean;
615: } catch (FinderException e) {
616: logger
617: .error("isSettingEnabled(SecuritySession, String)",
618: e);
619:
620: if (logger.isDebugEnabled()) {
621: logger
622: .debug("isSettingEnabled(SecuritySession, String) - end "
623: + "- return value = " + false);
624: }
625: return false;
626: } catch (Exception e) {
627: logger
628: .error("isSettingEnabled(SecuritySession, String)",
629: e);
630:
631: persistenceSession.cancel();
632: throw new SystemException(e);
633: } finally {
634: persistenceSession.close();
635: }
636: }
637:
638: /**
639: * <p>
640: * Revert a user setting back to the general value.
641: * </p>
642: *
643: * @param securitySession Used to authenticate the user.
644: * @param name The name of the setting to revert.
645: * @param user The name of the user to revert the setting for.
646: * @throws SystemException If there is a technical problem reverting the
647: * setting.
648: */
649: public void revertSetting(final SecuritySession securitySession,
650: final String name, final UserDO user)
651: throws SystemException {
652: if (logger.isDebugEnabled()) {
653: logger
654: .debug("revertSetting(SecuritySession securitySession = "
655: + securitySession
656: + ", String name = "
657: + name
658: + ", UserDO user = "
659: + user
660: + ") - start");
661: }
662:
663: assert (user != null);
664:
665: PersistenceSession persistenceSession = persistenceManager
666: .openSession(securitySession);
667: try {
668: SettingDO setting = (SettingDO) persistenceManager
669: .findInstance(persistenceSession,
670: "adminSettingByNameUserName", new Object[] {
671: name, user.getName() });
672: persistenceManager.remove(persistenceSession, setting);
673: } catch (FinderException e) {
674: logger
675: .error(
676: "revertSetting(SecuritySession, String, UserDO)",
677: e);
678:
679: // that's ok - the default value will already be used
680: } catch (Exception e) {
681: logger
682: .error(
683: "revertSetting(SecuritySession, String, UserDO)",
684: e);
685:
686: persistenceSession.cancel();
687: throw new SystemException(e);
688: } finally {
689: persistenceSession.close();
690: }
691:
692: if (logger.isDebugEnabled()) {
693: logger
694: .debug("revertSetting(SecuritySession, String, UserDO) -"
695: + " end");
696: }
697: }
698:
699: /**
700: * <p>Confirm all of the settings passed are correct.</p>
701: *
702: * @param securitySession Used to authenticate the user.
703: * @param settings A <code>Map</code> with setting names as keys and setting
704: * values as values
705: * @param locale The <code>Locale</code> to get localised error messages
706: * @param settingType One of the constants in <code>SettingConstants</code>:
707: * <code>SETTING_USER</code> or <code>SETTING_SYSTEM</code>
708: * @return A collection of validation errors if any of the settings
709: * contains invalid value.
710: * @throws SystemException If there is a technical problem.
711: */
712: public ValidationErrors validate(
713: final SecuritySession securitySession, final Map settings,
714: final Locale locale, final int settingType)
715: throws SystemException {
716: if (logger.isDebugEnabled()) {
717: logger.debug("validate(SecuritySession session = "
718: + securitySession + ", Map settings = " + settings
719: + ", Locale locale = " + locale
720: + ", int settingType = " + settingType
721: + ") - start");
722: }
723:
724: ResourceBundle resources = ResourceBundle.getBundle(
725: "com.ivata.groupware.admin.ApplicationResources",
726: locale);
727: ValidationErrors errors = new ValidationErrors();
728:
729: String settingAreaString = "";
730: if (settingType == SettingConstants.SETTING_SYSTEM) {
731: settingAreaString = resources.getString("setting.system");
732: } else if (settingType == SettingConstants.SETTING_USER) {
733: settingAreaString = resources.getString("setting.user");
734: }
735:
736: // go through all the passed settings and check the ones that need to be
737: // validated
738: String currentName = "";
739: Integer valueInteger;
740: for (Iterator i = settings.keySet().iterator(); i.hasNext();) {
741: currentName = (String) i.next();
742:
743: // required email string settings
744: if (currentName.equals("emailHost")
745: || currentName.equals("emailHostSmtp")
746: || currentName.equals("emailFolderInbox")
747: || currentName.equals("emailFolderSent")
748: || currentName.equals("emailFolderTrash")
749: || currentName.equals("emailFolderDrafts")) {
750:
751: if (StringHandling.isNullOrEmpty((String) settings
752: .get(currentName))) {
753: errors.add(new ValidationError(
754: "errors.setting.required",
755: Arrays.asList(new String[] {
756: settingAreaString,
757: resources
758: .getString("setting.field."
759: + currentName) })));
760: }
761:
762: // email port
763: } else if (currentName.equals("emailPort")) {
764: valueInteger = (Integer) settings.get(currentName);
765: if (valueInteger.intValue() < 1
766: || valueInteger.intValue() > Integer.MAX_VALUE) {
767: errors
768: .add(new ValidationError(
769: "errors.setting.range",
770: Arrays
771: .asList(new String[] {
772: settingAreaString,
773: resources
774: .getString("setting.field."
775: + currentName),
776: "1",
777: Integer
778: .toString(Integer.MAX_VALUE) })));
779:
780: }
781:
782: // library integer settings
783: } else if (currentName.equals("libraryHome")
784: || currentName.equals("libraryRecent")
785: || currentName.equals("libraryCommentSpacer")) {
786:
787: valueInteger = (Integer) settings.get(currentName);
788: if (valueInteger.intValue() < 1) {
789: errors
790: .add(new ValidationError(
791: "errors.setting.greaterThan",
792: Arrays
793: .asList(new String[] {
794: settingAreaString,
795: resources
796: .getString("setting.field."
797: + currentName),
798: "0" })));
799:
800: }
801:
802: // date formats
803: } else if (currentName.equals("i18nDateInputDisplay")
804: || currentName.equals("i18nDateLong")
805: || currentName.equals("i18nDateLongDay")
806: || currentName.equals("i18nDateLongYear")
807: || currentName.equals("i18nDateShort")
808: || currentName.equals("i18nDateShortYear")
809: || currentName.equals("i18nDateWeekDay")
810: || currentName.equals("i18nDateShortToday")
811: || currentName.equals("i18nDateShortYesterday")
812: || currentName.equals("i18nDateThisAfternoon")
813: || currentName.equals("i18nDateThisMorning")
814: || currentName.equals("i18nDateThisEvening")
815: || currentName.equals("i18nDateYesterdayMorning")
816: || currentName.equals("i18nDateYesterdayAfternoon")
817: || currentName.equals("i18nDateYesterdayEvening")) {
818:
819: // the validation of date formats
820: try {
821: new SimpleDateFormat((String) settings
822: .get(currentName));
823: } catch (IllegalArgumentException e) {
824: if (logger.isDebugEnabled()) {
825: logger
826: .debug(
827: "validate(SecuritySession, Map, Locale, int)",
828: e);
829: }
830:
831: errors.add(new ValidationError(
832: "errors.setting.date",
833: Arrays.asList(new String[] {
834: settingAreaString,
835: resources
836: .getString("setting.field."
837: + currentName) })));
838: }
839:
840: //time formats
841: } else if (currentName.equals("i18nTimeInputDisplay")
842: || currentName.equals("i18nTimeLong")
843: || currentName.equals("i18nTimeShort")) {
844:
845: // the validation of time formats
846: try {
847: new SimpleDateFormat((String) settings
848: .get(currentName));
849: } catch (IllegalArgumentException e) {
850: if (logger.isDebugEnabled()) {
851: logger
852: .debug(
853: "validate(SecuritySession, Map, Locale, int)",
854: e);
855: }
856:
857: errors.add(new ValidationError(
858: "errors.setting.time",
859: Arrays.asList(new String[] {
860: settingAreaString,
861: resources
862: .getString("setting.field."
863: + currentName) })));
864: }
865:
866: }
867:
868: }
869:
870: if (logger.isDebugEnabled()) {
871: logger
872: .debug("validate(SecuritySession, Map, Locale, int) - end "
873: + "- return value = " + errors);
874: }
875: return errors;
876: }
877: }
|