Java tutorial
/* This file is part of Cyclos (www.cyclos.org). A project of the Social Trade Organisation (www.socialtrade.org). Cyclos is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. Cyclos is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Cyclos; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package nl.strohalm.cyclos.services.settings; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import nl.strohalm.cyclos.dao.settings.SettingDAO; import nl.strohalm.cyclos.entities.customization.fields.MemberCustomField; import nl.strohalm.cyclos.entities.settings.AccessSettings; import nl.strohalm.cyclos.entities.settings.AlertSettings; import nl.strohalm.cyclos.entities.settings.LocalSettings; import nl.strohalm.cyclos.entities.settings.LogSettings; import nl.strohalm.cyclos.entities.settings.MailSettings; import nl.strohalm.cyclos.entities.settings.MailTranslation; import nl.strohalm.cyclos.entities.settings.MessageSettings; import nl.strohalm.cyclos.entities.settings.Setting; import nl.strohalm.cyclos.entities.settings.Setting.Type; import nl.strohalm.cyclos.entities.settings.events.AccessSettingsChangeListener; import nl.strohalm.cyclos.entities.settings.events.AlertSettingsChangeListener; import nl.strohalm.cyclos.entities.settings.events.LocalSettingsChangeListener; import nl.strohalm.cyclos.entities.settings.events.LogSettingsChangeListener; import nl.strohalm.cyclos.entities.settings.events.MailSettingsChangeListener; import nl.strohalm.cyclos.entities.settings.events.MailTranslationChangeListener; import nl.strohalm.cyclos.entities.settings.events.MessageSettingsChangeListener; import nl.strohalm.cyclos.entities.settings.events.SettingsChangeListener; import nl.strohalm.cyclos.services.InitializingService; import nl.strohalm.cyclos.services.fetch.FetchServiceLocal; import nl.strohalm.cyclos.services.settings.exceptions.SelectedSettingTypeNotInFileException; import nl.strohalm.cyclos.utils.EntityHelper; import nl.strohalm.cyclos.utils.XmlHelper; import nl.strohalm.cyclos.utils.conversion.CoercionHelper; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang.StringEscapeUtils; import org.apache.commons.lang.StringUtils; import org.springframework.beans.factory.InitializingBean; import org.w3c.dom.Document; import org.w3c.dom.Element; /** * Implementation class for settings service * @author luis * @author Jefferson Magno */ public class SettingsServiceImpl implements SettingsServiceLocal, InitializingService, InitializingBean { private static final String ROOT_ELEMENT = "cyclos-settings"; private static final String SETTINGS_ELEMENT = "settings"; private static final String SETTING_ELEMENT = "setting"; private static final List<String> IGNORED_SETTINGS = Arrays.asList("applicationName", "language"); private FetchServiceLocal fetchService; private SettingDAO settingDao; // Handlers for each settings type private Map<Setting.Type, SettingsHandler<?, ?>> handlersMap; private SettingsHandler<AccessSettings, AccessSettingsChangeListener> accessSettingsHandler; private SettingsHandler<AlertSettings, AlertSettingsChangeListener> alertSettingsHandler; private SettingsHandler<LocalSettings, LocalSettingsChangeListener> localSettingsHandler; private SettingsHandler<LogSettings, LogSettingsChangeListener> logSettingsHandler; private SettingsHandler<MailSettings, MailSettingsChangeListener> mailSettingsHandler; private SettingsHandler<MailTranslation, MailTranslationChangeListener> mailTranslationHandler; private SettingsHandler<MessageSettings, MessageSettingsChangeListener> messageSettingsHandler; private Set<SettingsChangeListener> listenersPendingToAdd = new HashSet<SettingsChangeListener>(); @Override public void addListener(final SettingsChangeListener listener) { // Before completing initialization, other components might want to register listeners, but handlers are not set yet. // So, we'll just add them after the initialization is complete if (listenersPendingToAdd != null) { listenersPendingToAdd.add(listener); return; } if (listener instanceof AccessSettingsChangeListener) { accessSettingsHandler.addListener((AccessSettingsChangeListener) listener); } if (listener instanceof AlertSettingsChangeListener) { alertSettingsHandler.addListener((AlertSettingsChangeListener) listener); } if (listener instanceof LocalSettingsChangeListener) { localSettingsHandler.addListener((LocalSettingsChangeListener) listener); } if (listener instanceof LogSettingsChangeListener) { logSettingsHandler.addListener((LogSettingsChangeListener) listener); } if (listener instanceof MailSettingsChangeListener) { mailSettingsHandler.addListener((MailSettingsChangeListener) listener); } if (listener instanceof MailTranslationChangeListener) { mailTranslationHandler.addListener((MailTranslationChangeListener) listener); } if (listener instanceof MessageSettingsChangeListener) { messageSettingsHandler.addListener((MessageSettingsChangeListener) listener); } } @Override public void afterPropertiesSet() throws Exception { // Create a map with all handlers by type handlersMap = new HashMap<Setting.Type, SettingsHandler<?, ?>>(); handlersMap.put(Setting.Type.ACCESS, accessSettingsHandler); handlersMap.put(Setting.Type.ALERT, alertSettingsHandler); handlersMap.put(Setting.Type.LOCAL, localSettingsHandler); handlersMap.put(Setting.Type.LOG, logSettingsHandler); handlersMap.put(Setting.Type.MAIL, mailSettingsHandler); handlersMap.put(Setting.Type.MAIL_TRANSLATION, mailTranslationHandler); handlersMap.put(Setting.Type.MESSAGE, messageSettingsHandler); // Add any listeners which were registered before the initialization was completed Set<SettingsChangeListener> listeners = listenersPendingToAdd; listenersPendingToAdd = null; for (SettingsChangeListener listener : listeners) { addListener(listener); } } @Override public String exportToXml(final Collection<Type> types) { final LocalSettings localSettings = getLocalSettings(); final StringBuilder xml = new StringBuilder(); xml.append("<?xml version=\"1.0\" encoding=\"").append(localSettings.getCharset()).append("\"?>\n"); xml.append('<').append(ROOT_ELEMENT).append(">\n"); for (final Type type : types) { appendSettingType(xml, type); } xml.append("</").append(ROOT_ELEMENT).append(">\n"); return xml.toString(); } @Override public AccessSettings getAccessSettings() { return accessSettingsHandler.get(); } @Override public AlertSettings getAlertSettings() { return alertSettingsHandler.get(); } @Override public LocalSettings getLocalSettings() { return localSettingsHandler.get(); } @Override public LogSettings getLogSettings() { return logSettingsHandler.get(); } @Override public MailSettings getMailSettings() { return mailSettingsHandler.get(); } @Override public MailTranslation getMailTranslation() { return mailTranslationHandler.get(); } @Override public MessageSettings getMessageSettings() { return messageSettingsHandler.get(); } @Override public MemberCustomField getSmsCustomField() { final Long id = getLocalSettings().getSmsCustomFieldId(); if (id == null) { return null; } final MemberCustomField reference = EntityHelper.reference(MemberCustomField.class, id); return fetchService.fetch(reference); } @Override public List<?> importFromXml(final String xml, final Collection<Setting.Type> types) { final Document doc = XmlHelper.readDocument(xml); final Element root = doc.getDocumentElement(); final List<Element> settingTypesNodes = XmlHelper.getChilden(root, SETTINGS_ELEMENT); final Set<Setting.Type> typesImported = new HashSet<Setting.Type>(); final List<Object> settings = new ArrayList<Object>(); for (final Element settingTypeNode : settingTypesNodes) { final String settingTypeName = settingTypeNode.getAttribute("type"); final Setting.Type type = CoercionHelper.coerce(Setting.Type.class, settingTypeName); if (!types.contains(type)) { continue; } final Map<String, String> values = new HashMap<String, String>(); final List<Element> settingsNodes = XmlHelper.getChilden(settingTypeNode, SETTING_ELEMENT); for (final Element settingNode : settingsNodes) { final String settingName = settingNode.getAttribute("name"); // Setting in ignore list, don't import it if (type == Setting.Type.LOCAL && IGNORED_SETTINGS.contains(settingName)) { continue; } String settingValue; try { settingValue = StringUtils.trimToNull(settingNode.getChildNodes().item(0).getNodeValue()); } catch (final Exception e) { settingValue = null; } values.put(settingName, settingValue); } final SettingsHandler<?, ?> settingsHandler = handlersMap.get(type); final Object setting = settingsHandler.importFrom(values); typesImported.add(type); settings.add(setting); } final List<Setting.Type> notImportedTypes = new ArrayList<Setting.Type>(); for (final Setting.Type type : types) { if (!typesImported.contains(type)) { notImportedTypes.add(type); } } if (CollectionUtils.isNotEmpty(notImportedTypes)) { throw new SelectedSettingTypeNotInFileException(notImportedTypes); } return settings; } @Override public void initializeService() { importNew(); } @Override public void reloadTranslation() { // Delete all mail and message translations settingDao.deleteByType(Setting.Type.MAIL_TRANSLATION, Setting.Type.MESSAGE); // Delete some local settings which are also 'translatable' for (final Setting setting : settingDao.listByType(Setting.Type.LOCAL)) { final String name = setting.getName(); if ("applicationUsername".equals(name) || "chargebackDescription".equals(name)) { settingDao.delete(setting.getId()); } } // Now import them all again, with the current language importNew(); // Then, refresh the handler's state refreshTranslationRelatedHandlers(); } @Override public void removeListener(final SettingsChangeListener listener) { if (listener instanceof AccessSettingsChangeListener) { accessSettingsHandler.removeListener((AccessSettingsChangeListener) listener); } if (listener instanceof AlertSettingsChangeListener) { alertSettingsHandler.removeListener((AlertSettingsChangeListener) listener); } if (listener instanceof LocalSettingsChangeListener) { localSettingsHandler.removeListener((LocalSettingsChangeListener) listener); } if (listener instanceof LogSettingsChangeListener) { logSettingsHandler.removeListener((LogSettingsChangeListener) listener); } if (listener instanceof MailSettingsChangeListener) { mailSettingsHandler.removeListener((MailSettingsChangeListener) listener); } if (listener instanceof MailTranslationChangeListener) { mailTranslationHandler.removeListener((MailTranslationChangeListener) listener); } if (listener instanceof MessageSettingsChangeListener) { messageSettingsHandler.removeListener((MessageSettingsChangeListener) listener); } } @Override public AccessSettings save(final AccessSettings settings) { return accessSettingsHandler.update(settings); } @Override public AlertSettings save(final AlertSettings settings) { return alertSettingsHandler.update(settings); } @Override public LocalSettings save(final LocalSettings settings) { return localSettingsHandler.update(settings); } @Override public LogSettings save(final LogSettings settings) { return logSettingsHandler.update(settings); } @Override public MailSettings save(final MailSettings settings) { return mailSettingsHandler.update(settings); } @Override public MailTranslation save(final MailTranslation settings) { return mailTranslationHandler.update(settings); } @Override public MessageSettings save(final MessageSettings settings) { return messageSettingsHandler.update(settings); } public void setAccessSettingsHandler( final SettingsHandler<AccessSettings, AccessSettingsChangeListener> accessSettingsHandler) { this.accessSettingsHandler = accessSettingsHandler; } public void setAlertSettingsHandler( final SettingsHandler<AlertSettings, AlertSettingsChangeListener> alertSettingsHandler) { this.alertSettingsHandler = alertSettingsHandler; } public void setFetchServiceLocal(final FetchServiceLocal fetchService) { this.fetchService = fetchService; } public void setLocalSettingsHandler( final SettingsHandler<LocalSettings, LocalSettingsChangeListener> localSettingsHandler) { this.localSettingsHandler = localSettingsHandler; } public void setLogSettingsHandler( final SettingsHandler<LogSettings, LogSettingsChangeListener> logSettingsHandler) { this.logSettingsHandler = logSettingsHandler; } public void setMailSettingsHandler( final SettingsHandler<MailSettings, MailSettingsChangeListener> mailSettingsHandler) { this.mailSettingsHandler = mailSettingsHandler; } public void setMailTranslationHandler( final SettingsHandler<MailTranslation, MailTranslationChangeListener> mailTranslationHandler) { this.mailTranslationHandler = mailTranslationHandler; } public void setMessageSettingsHandler( final SettingsHandler<MessageSettings, MessageSettingsChangeListener> messageSettingsHandler) { this.messageSettingsHandler = messageSettingsHandler; } public void setSettingDao(final SettingDAO settingDao) { this.settingDao = settingDao; } @Override public void validate(final AccessSettings settings) { accessSettingsHandler.validate(settings); } @Override public void validate(final AlertSettings settings) { alertSettingsHandler.validate(settings); } @Override public void validate(final LocalSettings settings) { localSettingsHandler.validate(settings); } @Override public void validate(final LogSettings settings) { logSettingsHandler.validate(settings); } @Override public void validate(final MailSettings settings) { mailSettingsHandler.validate(settings); } @Override public void validate(final MailTranslation settings) { mailTranslationHandler.validate(settings); } @Override public void validate(final MessageSettings settings) { messageSettingsHandler.validate(settings); } private void appendSetting(final StringBuilder xml, final Setting setting) { final String indent2Levels = StringUtils.repeat(" ", 2); final String indent3Levels = StringUtils.repeat(" ", 3); xml.append(indent2Levels).append(String.format("<setting name=\"%s\" >\n", setting.getName())); xml.append(indent3Levels).append(StringEscapeUtils.escapeXml(setting.getValue())); xml.append(indent2Levels).append("</setting>\n"); } private void appendSettingType(final StringBuilder xml, final Setting.Type type) { final String indent = StringUtils.repeat(" ", 1); xml.append(String.format("%s<settings type=\"%s\" >\n", indent, type.getValue())); final SettingsHandler<?, ?> handler = handlersMap.get(type); final List<Setting> settings = handler.listSettings(); for (final Setting setting : settings) { // Setting in ignore list, don't export it if (type == Setting.Type.LOCAL && IGNORED_SETTINGS.contains(setting.getName())) { continue; } appendSetting(xml, setting); } xml.append(indent).append("</settings>\n"); } private void importNew() { settingDao.importNew(getLocalSettings().getLocale()); refreshTranslationRelatedHandlers(); } private void refreshTranslationRelatedHandlers() { localSettingsHandler.refresh(); messageSettingsHandler.refresh(); mailTranslationHandler.refresh(); } }