com.enonic.cms.core.user.field.UserFieldTransformer.java Source code

Introduction

Here is the source code for com.enonic.cms.core.user.field.UserFieldTransformer.java

Source

/*
 * Copyright 2000-2013 Enonic AS
 * http://www.enonic.com/license
 */
package com.enonic.cms.core.user.field;

import java.util.HashMap;
import java.util.Map;

import org.apache.commons.fileupload.FileItem;

import com.enonic.esl.containers.ExtendedMap;

import com.enonic.cms.api.plugin.ext.userstore.UserField;
import com.enonic.cms.api.plugin.ext.userstore.UserFieldType;
import com.enonic.cms.api.plugin.ext.userstore.UserFields;
import com.enonic.cms.api.plugin.ext.userstore.UserStoreConfig;

public final class UserFieldTransformer {
    private final AddressTransformer addressTransformer = new AddressTransformer();

    private final UserFieldHelper helper = new UserFieldHelper();

    private boolean transformNullValuesToBlanksForConfiguredFields = false;

    private boolean transformNullHtmlEmailValueToFalseIfConfigured = false;

    private UserStoreConfig userStoreConfig = null;

    public UserFieldTransformer transformNullValuesToBlanksForConfiguredFields(UserStoreConfig userStoreConfig) {
        transformNullValuesToBlanksForConfiguredFields = true;
        this.userStoreConfig = userStoreConfig;
        return this;
    }

    public UserFieldTransformer transformNullHtmlEmailValueToFalseIfConfigured(UserStoreConfig userStoreConfig) {
        transformNullHtmlEmailValueToFalseIfConfigured = true;
        this.userStoreConfig = userStoreConfig;
        return this;
    }

    public UserFields toUserFields(ExtendedMap formValues) {
        Map<String, String> map = toStringStringMap(formValues);
        UserFields fields = fromStoreableMap(map);

        FileItem item = formValues.getFileItem(UserFieldType.PHOTO.getName(), null);
        if (item != null) {
            updatePhoto(fields, UserPhotoHelper.convertPhoto(item.get()));
        }

        return fields;
    }

    public UserFields fromStoreableMap(Map<String, String> map) {
        UserFields fields = new UserFields(true);
        for (UserFieldType type : UserFieldType.values()) {
            updateUserField(fields, type, map);
        }

        fields.addAll(this.addressTransformer.fromStoreableMap(map).getAll());
        return fields;
    }

    public void updatePhoto(UserFields fields, byte[] value) {
        if (value != null) {
            fields.add(new UserField(UserFieldType.PHOTO, value));
        }
    }

    public Map<String, String> toStoreableMap(UserFields fields) {
        HashMap<String, String> result = new HashMap<String, String>();
        for (UserField field : fields) {
            if (!field.isAddress() && !field.isPhoto()) {
                addSimpleField(result, field);
            }
        }

        result.putAll(this.addressTransformer.toStoreableMap(fields));
        return result;
    }

    private Map<String, String> toStringStringMap(ExtendedMap formValues) {
        HashMap<String, String> map = new HashMap<String, String>();
        for (Object key : formValues.keySet()) {
            String name = key.toString().replace("_", "-");
            Object value = formValues.get(key);

            if (value instanceof String) {
                map.put(name, (String) value);
            }
        }

        return map;
    }

    private void updateUserField(UserFields fields, UserFieldType type, Map<String, String> map) {
        if (type == UserFieldType.ADDRESS) {
            return;
        }

        if (type != UserFieldType.PHOTO) {
            updateSimpleField(fields, type, map);
        }
    }

    private void updateSimpleField(UserFields fields, UserFieldType type, Map<String, String> map) {
        String value = map.get(type.getName());

        if (value == null && type == UserFieldType.HTML_EMAIL && transformNullHtmlEmailValueToFalseIfConfigured
                && fieldIsConfigured(type)) {
            value = "false";
        } else if (value == null && transformNullValuesToBlanksForConfiguredFields && fieldIsConfigured(type)) {
            value = "";
        }

        if (value != null) {
            Object typedValue = this.helper.fromString(type, value);
            fields.add(new UserField(type, typedValue));
        }
    }

    private boolean fieldIsConfigured(UserFieldType type) {
        return userStoreConfig.getUserFieldConfig(type) != null;
    }

    private void addSimpleField(Map<String, String> result, UserField field) {
        UserFieldType type = field.getType();
        String strValue = this.helper.toString(field);

        if (!field.getType().isStringBased()) {
            addNullable(result, type.getName(), strValue);
        } else {
            addIfNotNull(result, type.getName(), strValue);
        }
    }

    private void addIfNotNull(Map<String, String> result, String name, String value) {
        if (value != null) {
            result.put(name, value);
        }
    }

    private void addNullable(Map<String, String> result, String name, String value) {
        result.put(name, value);
    }
}