BaseCustomFieldServiceImpl.java

/*
    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.customization;

import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Callable;

import nl.strohalm.cyclos.dao.customizations.CustomFieldDAO;
import nl.strohalm.cyclos.dao.customizations.CustomFieldPossibleValueDAO;
import nl.strohalm.cyclos.dao.customizations.CustomFieldValueDAO;
import nl.strohalm.cyclos.entities.Relationship;
import nl.strohalm.cyclos.entities.accounts.transactions.Transfer;
import nl.strohalm.cyclos.entities.customization.fields.CustomField;
import nl.strohalm.cyclos.entities.customization.fields.CustomField.Type;
import nl.strohalm.cyclos.entities.customization.fields.CustomFieldPossibleValue;
import nl.strohalm.cyclos.entities.customization.fields.CustomFieldValue;
import nl.strohalm.cyclos.entities.customization.fields.MemberCustomField;
import nl.strohalm.cyclos.entities.customization.fields.MemberCustomFieldValue;
import nl.strohalm.cyclos.entities.customization.fields.Validation;
import nl.strohalm.cyclos.entities.exceptions.EntityNotFoundException;
import nl.strohalm.cyclos.entities.members.Element;
import nl.strohalm.cyclos.entities.members.Element.Nature;
import nl.strohalm.cyclos.entities.members.Member;
import nl.strohalm.cyclos.entities.services.ServiceClient;
import nl.strohalm.cyclos.services.elements.ElementServiceLocal;
import nl.strohalm.cyclos.services.fetch.FetchServiceLocal;
import nl.strohalm.cyclos.services.permissions.PermissionServiceLocal;
import nl.strohalm.cyclos.services.settings.SettingsServiceLocal;
import nl.strohalm.cyclos.utils.CustomFieldHelper;
import nl.strohalm.cyclos.utils.CustomFieldsContainer;
import nl.strohalm.cyclos.utils.CustomObjectHandler;
import nl.strohalm.cyclos.utils.ElementVO;
import nl.strohalm.cyclos.utils.Pair;
import nl.strohalm.cyclos.utils.PropertyHelper;
import nl.strohalm.cyclos.utils.RangeConstraint;
import nl.strohalm.cyclos.utils.RelationshipHelper;
import nl.strohalm.cyclos.utils.StringHelper;
import nl.strohalm.cyclos.utils.access.LoggedUser;
import nl.strohalm.cyclos.utils.cache.Cache;
import nl.strohalm.cyclos.utils.cache.CacheCallback;
import nl.strohalm.cyclos.utils.cache.CacheManager;
import nl.strohalm.cyclos.utils.conversion.CalendarConverter;
import nl.strohalm.cyclos.utils.conversion.ConversionException;
import nl.strohalm.cyclos.utils.conversion.IdConverter;
import nl.strohalm.cyclos.utils.conversion.NumberConverter;
import nl.strohalm.cyclos.utils.lock.UniqueObjectHandler;
import nl.strohalm.cyclos.utils.validation.InvalidError;
import nl.strohalm.cyclos.utils.validation.LengthValidation;
import nl.strohalm.cyclos.utils.validation.PropertyValidation;
import nl.strohalm.cyclos.utils.validation.UniqueError;
import nl.strohalm.cyclos.utils.validation.ValidationError;
import nl.strohalm.cyclos.utils.validation.ValidationException;
import nl.strohalm.cyclos.utils.validation.Validator;
import nl.strohalm.cyclos.utils.validation.Validator.Property;
import nl.strohalm.cyclos.utils.validation.Validator.PropertyRetrieveStrategy;
import nl.strohalm.cyclos.webservices.model.FieldVO;
import nl.strohalm.cyclos.webservices.model.PossibleValueVO;
import nl.strohalm.cyclos.webservices.utils.FieldHelper;

import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.support.PropertyComparator;

/**
 * Base implementation for custom field services
 * @author luis
 */
public abstract class BaseCustomFieldServiceImpl<CF extends CustomField> implements BaseCustomFieldServiceLocal<CF> {

    /**
     * Validator for decimal fields
     * 
     * @author luis
     */
    public final class BigDecimalValidator implements PropertyValidation {
        private static final long serialVersionUID = -7933981104151866154L;

        @Override
        public ValidationError validate(final Object object, final Object property, final Object value) {
            final String str = (String) value;
            final NumberConverter<BigDecimal> numberConverter = settingsService.getLocalSettings().getNumberConverter();
            try {
                numberConverter.valueOf(str);
                return null;
            } catch (final ConversionException e) {
                return new InvalidError();
            }
        }
    }

    /**
     * Retrieving strategy for validating properties
     * @author luis
     */
    public class CustomFieldRetrievingStrategy implements PropertyRetrieveStrategy {

        private static final long serialVersionUID = 8667919404137289046L;
        private final CustomField field;

        public CustomFieldRetrievingStrategy(final CustomField field) {
            this.field = field;
        }

        @Override
        public Object description(final Object object, final String name) {
            return field;
        }

        @Override
        @SuppressWarnings("unchecked")
        public Object get(final Object object) {
            final Collection<? extends CustomFieldValue> values = (Collection<? extends CustomFieldValue>) PropertyHelper.get(object, "customValues");
            final CustomFieldValue fieldValue = customFieldHelper.findByField(field, values);
            String value = fieldValue == null ? null : fieldValue.getValue();
            if (StringUtils.isNotEmpty(field.getPattern())) {
                value = StringHelper.removeMask(field.getPattern(), value);
            }
            return value;
        }
    }

    /**
     * Validator for date fields
     * 
     * @author luis
     */
    public class DateValidator implements PropertyValidation {
        private static final long serialVersionUID = 5145399976834903999L;

        @Override
        public ValidationError validate(final Object object, final Object property, final Object value) {
            final String str = (String) value;
            final CalendarConverter dateConverter = settingsService.getLocalSettings().getRawDateConverter();
            try {
                final Calendar date = dateConverter.valueOf(str);
                if (date != null) {
                    final int year = date.get(Calendar.YEAR);
                    if (year < 1900 || year > 2100) {
                        return new InvalidError();
                    }
                }
                return null;
            } catch (final ConversionException e) {
                return new InvalidError();
            }
        }
    }

    /**
     * Validator for enumerated fields
     * 
     * @author luis
     */
    public class EnumeratedValidator implements PropertyValidation {
        private static final long serialVersionUID = 5145399976834903999L;

        @Override
        public ValidationError validate(final Object object, final Object property, final Object value) {
            final String str = (String) value;
            if (StringUtils.isEmpty(str)) {
                return null;
            }
            final CustomField field = (CustomField) property;
            CustomFieldPossibleValue possibleValue = null;

            possibleValue = loadPossibleValue(str, field);

            // Return error if not found
            return possibleValue == null ? new InvalidError() : null;
        }
    }

    /**
     * Validator for integer fields
     * 
     * @author luis
     */
    public class IntegerValidator implements PropertyValidation {
        private static final long serialVersionUID = 5145399976834903999L;

        @Override
        public ValidationError validate(final Object object, final Object property, final Object value) {
            final String str = (String) value;
            if (StringUtils.isNotEmpty(str) && !StringUtils.isNumeric(str)) {
                return new InvalidError();
            }
            return null;
        }
    }

    /**
     * Validates a java identifier
     * @author Jefferson Magno
     */
    public class JavaIdentifierValidation implements PropertyValidation {
        private static final long serialVersionUID = 259170291118675512L;

        @Override
        public ValidationError validate(final Object object, final Object property, final Object value) {
            final String string = (String) value;
            if (StringUtils.isNotEmpty(string) && !StringHelper.isValidJavaIdentifier(string)) {
                return new InvalidError();
            }
            return null;
        }
    }

    /**
     * Validator for member fields
     * 
     * @author luis
     */
    public class MemberValidator implements PropertyValidation {
        private static final long serialVersionUID = 5145399976834903999L;

        @Override
        public ValidationError validate(final Object object, final Object property, final Object value) {
            final String idStr = (String) value;
            if (StringUtils.isEmpty(idStr)) {
                return null;
            }
            if (StringUtils.isNotEmpty(idStr)) {
                Long id;
                try {
                    id = Long.valueOf(idStr);
                    ElementVO elementVO = elementService.getElementVO(id);
                    if (elementVO.getNature() != Nature.MEMBER) {
                        throw new Exception();
                    }
                } catch (Exception e) {
                    return new InvalidError();
                }
            }
            return null;
        }
    }

    /**
     * Validates the parent field
     * @author luis
     */
    public final class ParentValidator implements PropertyValidation {

        private static final long serialVersionUID = -6383825246336857857L;

        @Override
        @SuppressWarnings("unchecked")
        public ValidationError validate(final Object object, final Object property, final Object value) {
            final CF field = (CF) object;
            final CustomField parent = (CustomField) value;
            if (parent != null) {
                final List<CF> possibleParents = listPossibleParentFields(field);
                if (!possibleParents.contains(parent)) {
                    return new InvalidError();
                }
            }
            return null;
        }

    }

    /**
     * Validate that an enum field value contains a possible value according to its parent value
     * @author jcomas
     */
    public class ParentValueValidation implements PropertyValidation {
        private static final long serialVersionUID = 6222393116036296454L;

        @Override
        public ValidationError validate(final Object object, final Object data, final Object value) {
            CustomFieldsContainer<?, ?> c;
            if (!(object instanceof CustomFieldsContainer)) {
                return null;
            } else {
                c = (CustomFieldsContainer<?, ?>) object;
            }
            final CustomField field = (CustomField) data;

            CustomFieldValue customFieldValue = null;
            CustomFieldPossibleValue possibleValue = null;

            CustomFieldValue parentCustomFieldValue = null;
            CustomFieldPossibleValue parentPossibleValue = null;

            // Get the custom field values for actual field and its parent
            for (CustomFieldValue cfv : c.getCustomValues()) {
                if (customFieldValue == null && cfv.getField().getId() == field.getId()) {
                    customFieldValue = cfv;
                } else if (parentCustomFieldValue == null && cfv.getField().getId() == field.getParent().getId()) {
                    parentCustomFieldValue = cfv;
                }
                if (customFieldValue != null && parentCustomFieldValue != null) {
                    break;
                }
            }

            // If no customFieldValue, there is nothing to check
            if (customFieldValue == null) {
                return null;
            }

            // Get the possible values for actual and parent
            possibleValue = loadPossibleValue(customFieldValue);

            // If no possible value, there is nothing to check
            if (possibleValue == null) {
                return null;
            }

            parentPossibleValue = loadPossibleValue(parentCustomFieldValue);

            if (parentPossibleValue == null || !parentPossibleValue.equals(possibleValue.getParent())) {
                return new ValidationError("expected value " + possibleValue.getParent() + " in parent of field " + field);
            }

            return null;
        }
    }

    /**
     * A cache key for possible values. Cannot use the id itself to differentiate it from the field id
     * 
     * @author luis
     */
    public static class PossibleValueKey implements Serializable {
        private static final long serialVersionUID = 6220627534414217532L;
        private final long        id;

        public PossibleValueKey(final long id) {
            this.id = id;
        }

        @Override
        public boolean equals(final Object obj) {
            if (!(obj instanceof PossibleValueKey)) {
                return false;
            }
            PossibleValueKey key = (PossibleValueKey) obj;
            return id == key.id;
        }

        @Override
        public int hashCode() {
            return (int) id;
        }

    }

    /**
     * Validator to ensure the internal name is unique
     * 
     * @author luis
     */
    public class UniqueCustomFieldInternalNameValidation implements PropertyValidation {
        private static final long serialVersionUID = 1L;

        @Override
        public ValidationError validate(final Object object, final Object property, final Object value) {
            final CustomField field = (CustomField) object;

            if (field.getInternalName() == null || field.getInternalName().equals("")) {
                return null;
            }

            return customFieldDao.isInternalNameUsed(field) ? new UniqueError(field.getInternalName()) : null;
        }
    }

    /**
     * Validates an unique field value
     * @author luis
     */
    public class UniqueFieldValueValidation implements PropertyValidation {
        private static final long serialVersionUID = 6222393116036296454L;

        @Override
        public ValidationError validate(final Object object, final Object data, final Object value) {
            if (!(object instanceof CustomFieldsContainer<?, ?>)) {
                return null;
            }
            if (object instanceof Transfer && ((Transfer) object).getScheduledPayment() != null) {
                // We cannot validate unique on scheduled payment installments, as all installments share the same values, and would always fail
                return null;
            }
            final CustomField field = (CustomField) data;
            final String string = (String) value;
            if (StringUtils.isNotEmpty(string)) {
                // Build a field value
                CustomFieldValue fieldValue;
                try {
                    fieldValue = field.getNature().getValueType().newInstance();
                } catch (final Exception e) {
                    throw new RuntimeException(e);
                }
                fieldValue.setField(field);
                fieldValue.setOwner(object);
                fieldValue.setStringValue(string);

                // Check uniqueness
                if (customFieldValueDao.valueExists(fieldValue)) {
                    return new UniqueError(fieldValue.getStringValue());
                }
            }
            return null;
        }
    }

    private Validator                     possibleValueNavigator;

    protected static final String         ALL_KEY = "_ALL_";

    protected static final List<String>   EXCLUDED_PROPERTIES_FOR_DEPENDENT_FIELDS;

    static {
        final List<String> excluded = new ArrayList<String>();
        excluded.add("class");
        excluded.add("id");
        excluded.add("name");
        excluded.add("internalName");
        excluded.add("parent");
        excluded.add("description");
        excluded.add("allSelectedLabel");
        excluded.add("type");
        excluded.add("control");
        excluded.add("size");
        excluded.add("description");
        excluded.add("possibleValues");
        excluded.add("children");
        EXCLUDED_PROPERTIES_FOR_DEPENDENT_FIELDS = Collections.unmodifiableList(excluded);
    }

    protected final Class<CF>             customFieldType;
    protected FetchServiceLocal           fetchService;
    protected PermissionServiceLocal      permissionService;
    protected ElementServiceLocal         elementService;
    protected SettingsServiceLocal        settingsService;
    protected CustomFieldDAO              customFieldDao;
    protected CustomFieldValueDAO         customFieldValueDao;
    protected CustomFieldPossibleValueDAO customFieldPossibleValueDao;
    private CacheManager                  cacheManager;
    protected final Relationship[]        fetch;
    private Validator                     validator;
    protected CustomObjectHandler         customObjectHandler;
    protected FieldHelper                 fieldHelper;
    protected CustomFieldHelper           customFieldHelper;
    private UniqueObjectHandler           uniqueObjectHandler;

    protected BaseCustomFieldServiceImpl(final Class<CF> customFieldType) {
        this.customFieldType = customFieldType;
        Collection<Relationship> fetch = new ArrayList<Relationship>();
        fetch.addAll(Arrays.asList(CustomField.Relationships.POSSIBLE_VALUES, CustomField.Relationships.CHILDREN, RelationshipHelper.nested(CustomField.Relationships.PARENT, CustomField.Relationships.POSSIBLE_VALUES)));
        fetch.addAll(resolveAdditionalFetch());
        this.fetch = fetch.toArray(new Relationship[fetch.size()]);
    }

    @Override
    public void clearCache() {
        getCache().clear();
    }

    @Override
    public FieldVO getFieldVO(final Long customFieldId) {
        if (customFieldId == null) {
            return null;
        }
        CustomField cf = load(customFieldId);
        return fieldHelper.toVO(cf);
    }

    @Override
    public List<FieldVO> getFieldVOs(final List<Long> customFieldIds) {
        if (customFieldIds == null) {
            return null;
        }
        List<CustomField> customFields = new ArrayList<CustomField>(customFieldIds.size());
        for (Long id : customFieldIds) {
            if (id != null) {
                CustomField cf = load(id);
                customFields.add(cf);
            }
        }
        return fieldHelper.toFieldVOs(customFields);
    }

    @Override
    public List<PossibleValueVO> getPossibleValueVOs(final Long customFieldId, final Long possibleValueParentId) {
        if (customFieldId == null) {
            return null;
        }
        CF cf = load(customFieldId);

        if (cf.getType() != CustomField.Type.ENUMERATED) {
            return null;
        }
        FieldVO fieldVO = fieldHelper.toVO(cf);
        List<PossibleValueVO> possibleValues = fieldVO.getPossibleValues();
        if (possibleValues != null) {
            if (possibleValueParentId != null) {
                // Remove all the possible values that doesn't have parentValueId as parent
                for (PossibleValueVO pvo : possibleValues) {
                    if (!pvo.getParentId().equals(possibleValueParentId)) {
                        possibleValues.remove(pvo);
                    }
                }
            }
            return possibleValues;
        } else {
            return Collections.emptyList();
        }
    }

    @Override
    public List<CF> listPossibleParentFields(final CF field) {
        if (field == null || (field.isPersistent() && field.getType() != CustomField.Type.ENUMERATED)) {
            return new ArrayList<CF>();
        }
        final List<CF> fields = new ArrayList<CF>(list(field));

        // Remove the field itself, those which are not enumerated and those who already have a parent (don't allow multiple levels)
        for (final Iterator<CF> iterator = fields.iterator(); iterator.hasNext();) {
            final CF current = iterator.next();
            if (field.equals(current) || current.getType() != CustomField.Type.ENUMERATED || current.getControl() != CustomField.Control.SELECT || current.getParent() != null) {
                iterator.remove();
            }
        }
        return fields;
    }

    @Override
    public List<CF> load(final Collection<Long> ids) {
        List<CF> result = new ArrayList<CF>(ids.size());
        for (Long id : ids) {
            result.add(load(id));
        }
        return result;
    }

    @Override
    public CF load(final Long id) {
        return getCache().<CF> get(id, new CacheCallback() {
            @Override
            public Object retrieve() {
                return loadChecked(id);
            }
        });
    }

    @Override
    public CustomFieldPossibleValue loadPossibleValue(final Long id) {
        return getCache().get("_POSSIBLE_VALUE_" + id, new CacheCallback() {
            @Override
            public Object retrieve() {
                return loadCheckedPossibleValue(id);
            }
        });
    }

    @Override
    @SuppressWarnings("unchecked")
    public List<CustomFieldPossibleValue> loadPossibleValues(final Collection<Long> ids) {
        List<CustomFieldPossibleValue> result = new ArrayList<CustomFieldPossibleValue>(ids.size());
        for (Long id : ids) {
            result.add(loadPossibleValue(id));
        }
        Collections.sort(result, new BeanComparator("value"));
        return result;
    }

    @Override
    public int remove(final Long... ids) {
        for (Long id : ids) {
            CustomField field = customFieldDao.load(id);
            if (!customFieldType.isInstance(field)) {
                throw new EntityNotFoundException();
            }
        }
        getCache().clear();
        return customFieldDao.delete(ids);
    }

    @Override
    public int removePossibleValue(final Long... ids) {
        for (Long id : ids) {
            loadCheckedPossibleValue(id);
        }
        getCache().clear();
        return customFieldPossibleValueDao.delete(ids);
    }

    @Override
    public int replacePossibleValues(CustomFieldPossibleValue oldValue, CustomFieldPossibleValue newValue) {
        oldValue = fetchService.fetch(oldValue);
        newValue = fetchService.fetch(newValue);
        if (!oldValue.getField().equals(newValue.getField())) {
            throw new ValidationException();
        }
        return customFieldValueDao.moveValues(oldValue, newValue);
    }

    @Override
    public CF save(CF field) {
        // Special handling for fields with a parent field
        CustomField parent = null;
        if (field.getParent() != null) {
            // When the field has a parent, several settings are copied from it
            parent = fetchService.fetch(field.getParent());
            copyParentProperties(parent, field);
        }
        validate(field);
        if (field.isTransient()) {
            field.setChildren(new ArrayList<CustomField>());

            if (parent == null) {
                int maxOrder = 0;
                for (CF cf : list(field)) {
                    if (cf.getOrder() > maxOrder) {
                        maxOrder = cf.getOrder();
                    }
                }
                // Top level fields: set the order after other fields
                field.setOrder(maxOrder + 1);
            } else {
                parent.getChildren().add(field);
            }

            // Save the field
            field = customFieldDao.insert(field);

            if (parent != null) {
                // Nested fields: position the field just after his parent
                final List<Long> order = new ArrayList<Long>();
                List<CF> allFields = list(field);
                for (int i = 0; i < allFields.size(); i++) {
                    CF cf = allFields.get(i);
                    if (cf.getParent() != null) {
                        continue;
                    }
                    order.add(cf.getId());
                }
                setOrder(order);
            }
        } else {
            // Keep the order
            final CustomField oldversion = customFieldDao.load(field.getId());
            // in case of member custom fields, if set unhidden, all existing values must be unhidden
            // TODO RINKE 1: TEST
            if (oldversion instanceof MemberCustomField) {
                final MemberCustomField oldversionMemberField = (MemberCustomField) oldversion;
                final MemberCustomField newversion = (MemberCustomField) field;
                if (oldversionMemberField.isMemberCanHide() && !newversion.isMemberCanHide()) {
                    // set all present field values to unhide
                    customFieldValueDao.unHideValues(newversion);
                }
            }
            field.setOrder(oldversion.getOrder());

            field = customFieldDao.update(field);

            // Update the dependent properties for child fields
            if (field.getType() == CustomField.Type.ENUMERATED) {
                field = fetchService.reload(field, CustomField.Relationships.CHILDREN);
                for (final CustomField child : field.getChildren()) {
                    copyParentProperties(field, child);
                }
            }
        }
        getCache().clear();
        return field;
    }

    @Override
    public CustomFieldPossibleValue save(CustomFieldPossibleValue possibleValue) throws ValidationException {
        validate(possibleValue);
        try {
            if (possibleValue.isTransient()) {
                possibleValue = customFieldPossibleValueDao.insert(possibleValue);
            } else {
                possibleValue = customFieldPossibleValueDao.update(possibleValue);
            }
            customFieldPossibleValueDao.ensureDefault(possibleValue);
        } finally {
            getCache().clear();
        }
        return possibleValue;
    }

    public final void setCacheManager(final CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }

    public final void setCustomFieldDao(final CustomFieldDAO customFieldDao) {
        this.customFieldDao = customFieldDao;
    }

    public void setCustomFieldHelper(final CustomFieldHelper customFieldHelper) {
        this.customFieldHelper = customFieldHelper;
    }

    public final void setCustomFieldPossibleValueDao(final CustomFieldPossibleValueDAO customFieldPossibleValueDao) {
        this.customFieldPossibleValueDao = customFieldPossibleValueDao;
    }

    public final void setCustomFieldValueDao(final CustomFieldValueDAO customFieldValueDao) {
        this.customFieldValueDao = customFieldValueDao;
    }

    public final void setCustomObjectHandler(final CustomObjectHandler customObjectHandler) {
        this.customObjectHandler = customObjectHandler;
    }

    public final void setElementServiceLocal(final ElementServiceLocal elementService) {
        this.elementService = elementService;
    }

    public final void setFetchServiceLocal(final FetchServiceLocal fetchService) {
        this.fetchService = fetchService;
    }

    public final void setFieldHelper(final FieldHelper fieldHelper) {
        this.fieldHelper = fieldHelper;
    }

    @Override
    @SuppressWarnings("unchecked")
    public void setOrder(final List<Long> ids) {
        int order = 0;
        for (Long id : ids) {
            CF field = loadChecked(id);
            field.setOrder(++order);
            List<CustomField> children = new ArrayList<CustomField>(field.getChildren());
            if (CollectionUtils.isNotEmpty(children)) {
                Collections.sort(children, new PropertyComparator("name", true, true));
                for (CustomField child : children) {
                    child.setOrder(++order);
                }
            }
        }
        getCache().clear();
    }

    public final void setPermissionServiceLocal(final PermissionServiceLocal permissionService) {
        this.permissionService = permissionService;
    }

    public final void setSettingsServiceLocal(final SettingsServiceLocal settingsService) {
        this.settingsService = settingsService;
    }

    public void setUniqueObjectHandler(final UniqueObjectHandler uniqueObjectHandler) {
        this.uniqueObjectHandler = uniqueObjectHandler;
    }

    @Override
    public void validate(final CF field) {
        getValidator().validate(field);
    }

    @Override
    public void validate(final CustomFieldPossibleValue possibleValue) throws ValidationException {
        getPossibleValueValidator().validate(possibleValue);
    }

    /**
     * May be overridden in order to append any custom validations
     */
    protected void appendValidations(final Validator validator) {
    }

    protected void doSaveValues(final CustomFieldsContainer<?, ?> owner) {
        final Collection<? extends CustomFieldValue> customValues = owner.getCustomValues();
        if (customValues == null || customValues.isEmpty()) {
            return;
        }

        for (final CustomFieldValue value : customValues) {
            // Retrieve the field value
            final CustomField field = fetchService.fetch(value.getField());
            lockUniqueFieldValue(field, value);
            value.setField(field);
            CustomFieldPossibleValue possibleValue = null;
            Member memberValue = null;
            String stringValue = null;
            switch (field.getType()) {
                case ENUMERATED:
                    // Load the possible value
                    Long possibleValueId = null;
                    if (value.getPossibleValue() != null) {
                        possibleValueId = value.getPossibleValue().getId();
                    } else {
                        possibleValueId = IdConverter.instance().valueOf(value.getValue());
                    }
                    boolean tryByValue = possibleValueId == null;
                    boolean invalidPossibleValue = false;
                    if (possibleValueId != null) {
                        // Try by id
                        try {
                            possibleValue = customFieldPossibleValueDao.load(possibleValueId);
                            invalidPossibleValue = !possibleValue.isEnabled();
                        } catch (final EntityNotFoundException e) {
                            tryByValue = true;
                        }
                    }
                    if (tryByValue && StringUtils.isNotEmpty(value.getValue())) {
                        // Try by field id + value
                        try {
                            possibleValue = customFieldPossibleValueDao.load(field.getId(), value.getValue());
                            invalidPossibleValue = !possibleValue.isEnabled();
                        } catch (final EntityNotFoundException e) {
                            invalidPossibleValue = true;
                        }
                    }
                    if (invalidPossibleValue) {
                        throw createValidationException(field);
                    }
                    break;
                case MEMBER:
                    Long memberId = null;
                    if (value.getMemberValue() != null) {
                        memberId = value.getMemberValue().getId();
                    } else {
                        memberId = IdConverter.instance().valueOf(value.getValue());
                    }
                    if (memberId != null) {
                        boolean invalidMember = false;
                        try {
                            final Long mid = memberId;
                            memberValue = LoggedUser.runAsSystem(new Callable<Member>() {
                                @Override
                                public Member call() throws Exception {
                                    Element element = elementService.load(mid);
                                    if (!(element instanceof Member)) {
                                        throw new EntityNotFoundException();
                                    }
                                    return (Member) element;
                                }
                            });
                        } catch (final EntityNotFoundException e) {
                            invalidMember = true;
                        }
                        if (invalidMember) {
                            throw createValidationException(field);
                        }
                    }
                    break;
                default:
                    if ((field.getType() != CustomField.Type.STRING) || (field.getControl() != CustomField.Control.RICH_EDITOR)) {
                        stringValue = StringHelper.removeMarkupTags(value.getValue());
                    } else {
                        stringValue = value.getValue();
                    }

                    // A String value
                    stringValue = StringUtils.trimToNull(stringValue);
                    if (StringUtils.isNotEmpty(field.getPattern())) {
                        stringValue = StringHelper.removeMask(field.getPattern(), stringValue);
                    }
                    break;
            }
            // Check if the value exists for the given owner
            try {
                final CustomFieldValue existing = customFieldValueDao.load(field, owner);
                // Exists - just update the value
                existing.setStringValue(stringValue);
                existing.setPossibleValue(possibleValue);
                existing.setMemberValue(memberValue);
                if (value instanceof MemberCustomFieldValue) {
                    ((MemberCustomFieldValue) existing).setHidden(((MemberCustomFieldValue) value).isHidden());
                }
                customFieldValueDao.update(existing);
            } catch (final EntityNotFoundException e) {
                // Does not exists yet - insert a new value
                value.setOwner(owner);
                value.setStringValue(stringValue);
                value.setPossibleValue(possibleValue);
                value.setMemberValue(memberValue);
                if (value.isTransient()) {
                    customFieldValueDao.insert(value);
                } else {
                    customFieldValueDao.update(value);
                }
            }
        }
    }

    protected Cache getCache() {
        return cacheManager.getCache("cyclos.cache.CustomFields." + customFieldType.getSimpleName());
    }

    protected Validator getValueValidator(final Collection<? extends CustomField> fields) {
        final Validator validator = new Validator();

        for (CustomField field : fields) {
            field = fetchService.fetch(field);
            final Property property = validator.property(field.getInternalName(), new CustomFieldRetrievingStrategy(field));
            property.displayName(field.getName());

            switch (field.getType()) {
                case BOOLEAN:
                    property.anyOf("true", "false");
                    break;
                case INTEGER:
                    property.add(new IntegerValidator());
                    break;
                case DATE:
                    property.add(new DateValidator());
                    break;
                case ENUMERATED:
                    property.add(new EnumeratedValidator());
                    break;
                case MEMBER:
                    property.add(new MemberValidator());
                    break;
                case DECIMAL:
                    property.add(new BigDecimalValidator());
                    break;
                case URL:
                    property.url(true);
                    break;
            }

            final Validation validation = field.getValidation();
            if (validation != null) {
                // Check required
                boolean ignoreRequired = false;
                if (field instanceof MemberCustomField) {
                    ServiceClient client = LoggedUser.serviceClient();
                    ignoreRequired = client != null && client.isIgnoreRegistrationValidations();
                }
                if (validation.isRequired() && !ignoreRequired) {
                    property.required();
                }
                // Check length constraint
                final RangeConstraint lengthConstraint = validation.getLengthConstraint();
                if (lengthConstraint != null) {
                    property.add(new LengthValidation(lengthConstraint));
                }
                // Check unique
                if (validation.isUnique()) {
                    property.add(new UniqueFieldValueValidation());
                }
                // Custom validator class
                if (StringUtils.isNotEmpty(validation.getValidatorClass())) {
                    final PropertyValidation validatorClass = customObjectHandler.get(validation.getValidatorClass());
                    property.add(validatorClass);
                }
                // Check that if enumerated, its value is consistent with the parent value
                if (field.getType() == Type.ENUMERATED && field.getParent() != null) {
                    property.add(new ParentValueValidation());
                }
            }
        }
        return validator;
    }

    /**
     * Should be implemented in order to list all fields like the given one. When fields are not dependent on other entities (like member / ads /
     * admin / loan group) should return all. For others, like member record, should return all fields in the same member record as the given field
     */
    protected abstract List<CF> list(CF field);

    /**
     * It locks the custom field value only if it's set as unique.
     * @param value
     */
    protected void lockUniqueFieldValue(final CustomField field, final CustomFieldValue value) {
        if (field.getValidation().isUnique()) {
            final Pair<Object, Object> pair = Pair.<Object, Object> of(field, value.getValue());
            if (!uniqueObjectHandler.tryAcquire(pair)) {
                throw new ValidationException(new UniqueError(field.getName()));
            }
        }
    }

    /**
     * Must be implemented in order to resolve additional fetch to be applied before fields are stored on the cache
     */
    protected Collection<? extends Relationship> resolveAdditionalFetch() {
        return Collections.emptySet();
    }

    @SuppressWarnings("unchecked")
    private void copyParentProperties(final CustomField parent, final CustomField child) {
        final PropertyDescriptor[] propertyDescriptors = PropertyUtils.getPropertyDescriptors(parent);
        for (final PropertyDescriptor propertyDescriptor : propertyDescriptors) {
            final String name = propertyDescriptor.getName();
            final boolean isWritable = propertyDescriptor.getWriteMethod() != null;
            final boolean isReadable = propertyDescriptor.getReadMethod() != null;
            if (isReadable && isWritable && !EXCLUDED_PROPERTIES_FOR_DEPENDENT_FIELDS.contains(name)) {
                Object value = PropertyHelper.get(parent, name);
                if (value instanceof Collection) {
                    value = new ArrayList<Object>((Collection<Object>) value);
                }
                PropertyHelper.set(child, name, value);
            }
        }
    }

    private ValidationException createValidationException(final CustomField field) {
        final ValidationException vex = new ValidationException(field.getInternalName(), new InvalidError());
        vex.setDisplayNameByProperty(Collections.singletonMap(field.getInternalName(), field.getName()));
        return vex;
    }

    private Validator getPossibleValueValidator() {
        if (possibleValueNavigator == null) {
            final Validator validator = new Validator("customField.possibleValue");
            validator.property("field").required();
            validator.property("value").required().maxLength(255);
            possibleValueNavigator = validator;
        }
        return possibleValueNavigator;
    }

    private Validator getValidator() {
        if (validator == null) {
            // We use a separate variable name to avoid concurrency problems with 2 threads modifying the same reference
            Validator val = new Validator("customField");
            val.property("internalName").required().maxLength(50).add(new JavaIdentifierValidation()).add(new UniqueCustomFieldInternalNameValidation());
            val.property("name").required().maxLength(100);
            val.property("type").required();
            val.property("control").required();
            val.property("size").required();
            val.property("parent").add(new ParentValidator());
            val.property("validation.validatorClass").instanceOf(PropertyValidation.class);
            appendValidations(val);
            validator = val;
        }
        return validator;
    }

    /**
     * Loads a field, but only if it is of the expected type. Otherwise, throws an {@link EntityNotFoundException}
     */
    private CF loadChecked(final Long id) {
        CF field = customFieldDao.<CF> load(id, fetch);
        if (!customFieldType.isInstance(field)) {
            throw new EntityNotFoundException();
        }
        return field;
    }

    /**
     * Loads a possible value, fetching both parent and field relationships, but throws an {@link EntityNotFoundException} if the field is not of the
     * expected type
     */
    private CustomFieldPossibleValue loadCheckedPossibleValue(final Long id) {
        CustomFieldPossibleValue possibleValue = customFieldPossibleValueDao.load(id, CustomFieldPossibleValue.Relationships.PARENT, CustomFieldPossibleValue.Relationships.FIELD);
        if (!customFieldType.isInstance(possibleValue.getField())) {
            throw new EntityNotFoundException();
        }
        return possibleValue;
    }

    private CustomFieldPossibleValue loadPossibleValue(final CustomFieldValue v) {
        if (v.getPossibleValue() != null) {
            return v.getPossibleValue();
        } else if (StringUtils.isEmpty(v.getValue())) {
            return null;
        } else {
            return loadPossibleValue(v.getValue(), v.getField());
        }
    }

    private CustomFieldPossibleValue loadPossibleValue(final String str, final CustomField field) {
        CustomFieldPossibleValue possibleValue = null;
        boolean byValue = true;
        try {
            if (StringUtils.isNumeric(str)) {
                try {
                    possibleValue = customFieldPossibleValueDao.load(new Long(str));
                    if (field.equals(possibleValue.getField())) {
                        byValue = false;
                    }
                } catch (final EntityNotFoundException e) {
                    // Not found - try by value
                }
            }
            if (byValue) {
                // Try by value
                possibleValue = customFieldPossibleValueDao.load(field.getId(), str);
            }
        } catch (final EntityNotFoundException e) {
            possibleValue = null;
        }
        return possibleValue;
    }
}