kr.jm.metric.mutator.FieldConfigHandler Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jm-metric Show documentation
FieldMap Transformer From Various Formatted Data
There is a newer version: 0.2.7.3
package kr.jm.metric.mutator;

import kr.jm.metric.config.ConfigInterface;
import kr.jm.metric.config.mutator.MutatorConfigInterface;
import kr.jm.metric.config.mutator.MutatorConfigType;
import kr.jm.metric.config.mutator.field.DataType;
import kr.jm.metric.config.mutator.field.DateFormatConfig;
import kr.jm.metric.config.mutator.field.FieldConfig;
import kr.jm.utils.datastructure.JMMap;
import kr.jm.utils.exception.JMExceptionManager;
import kr.jm.utils.helper.JMOptional;
import kr.jm.utils.helper.JMStream;
import kr.jm.utils.helper.JMString;
import lombok.extern.slf4j.Slf4j;

import java.util.*;

import static kr.jm.metric.config.mutator.field.FieldConfig.RAW_DATA;

@Slf4j
class FieldConfigHandler {

    private String mutatorId;
    private Map formatMutatorConfigMap;
    private FieldConfig fieldConfig;

    FieldConfigHandler(String mutatorId, FieldConfig fieldConfig) {
        this.mutatorId = mutatorId;
        this.fieldConfig = fieldConfig;
        this.formatMutatorConfigMap = new HashMap<>();
    }

    public Map applyFieldConfig(
            Map fieldObjectMap) {
        fieldObjectMap = new HashMap<>(fieldObjectMap);
        applyFormat(fieldObjectMap);
        applyRawData(fieldObjectMap);
        applyCombinedFields(fieldObjectMap);
        applyFormulaFields(fieldObjectMap);
        applyDateFormat(fieldObjectMap);
        applyDataType(fieldObjectMap);
        applyAlterFieldName(fieldObjectMap);
        applyIgnore(fieldObjectMap);
        applyCustom(fieldObjectMap);
        return fieldObjectMap;
    }

    private void applyCustom(Map fieldObjectMap) {
        JMOptional.getOptional(this.fieldConfig.getCustom())
                .ifPresent(fieldObjectMap::putAll);
    }

    private void applyAlterFieldName(Map fieldObjectMap) {
        JMOptional.getOptional(this.fieldConfig.getAlterFieldName())
                .stream().map(Map::entrySet).flatMap(Set::stream)
                .filter(entry -> fieldObjectMap.containsKey(entry.getKey()))
                .filter(entry -> JMString.isNotNullOrEmpty(entry.getValue()))
                .forEach(entry -> fieldObjectMap.put(entry.getValue(),
                        fieldObjectMap.remove(entry.getKey())));
    }

    private void applyDataType(Map fieldObjectMap) {
        JMStream.buildEntryStream(this.fieldConfig.getDataType())
                .filter(entry -> fieldObjectMap.containsKey(entry.getKey()))
                .forEach(entry -> fieldObjectMap.put(entry.getKey(),
                        transformToNumber(entry.getValue(),
                                fieldObjectMap.get(entry.getKey())
                                        .toString())));
    }

    private Object transformToNumber(DataType dataType, String data) {
        switch (dataType) {
            case NUMBER:
                return transformToNumber(data);
            case LONG:
                return transformToNumber(data).longValue();
            default:
                return data;
        }
    }

    private Double transformToNumber(String data) {
        return JMString.isNumber(data) ? Double
                .valueOf(data) : JMExceptionManager
                .handleExceptionAndReturn(log,
                        new RuntimeException("Wrong Number Format Occur !!!"),
                        "transformToNumber", () -> 0D, mutatorId, data);
    }

    private void applyDateFormat(Map fieldObjectMap) {
        JMStream.buildEntryStream(this.fieldConfig.getDateFormat())
                .filter(entry -> fieldObjectMap.containsKey(entry.getKey()))
                .forEach(entry -> applyDateFormat(entry.getKey(), entry
                        .getValue(), fieldObjectMap));
    }

    private void applyDateFormat(String field,
            DateFormatConfig dateFormatConfig,
            Map fieldObjectMap) {
        fieldObjectMap
                .put(Optional.ofNullable(dateFormatConfig.getNewFieldName())
                                .orElse(field),
                        dateFormatConfig.change(fieldObjectMap.get(field)));
    }

    private void applyIgnore(Map fieldObjectMap) {
        JMOptional.getOptional(this.fieldConfig.getIgnore())
                .ifPresent(ignoreList -> ignoreList
                        .forEach(fieldObjectMap::remove));
    }

    private void applyRawData(Map fieldObjectMap) {
        if (!this.fieldConfig.isRawData())
            fieldObjectMap.remove(RAW_DATA);
    }

    private void applyFormulaFields(Map fieldObjectMap) {
        JMOptional.getOptional(this.fieldConfig.getFormulaFields()).stream()
                .flatMap(Arrays::stream)
                .forEach(formulaFieldConfig -> Optional.ofNullable(
                        formulaFieldConfig.buildValue(fieldObjectMap))
                        .ifPresent(value -> fieldObjectMap
                                .put(formulaFieldConfig.getCombinedFieldName(),
                                        value)));
    }

    private void applyCombinedFields(Map fieldObjectMap) {
        JMOptional.getOptional(this.fieldConfig.getCombinedFields()).stream()
                .flatMap(Arrays::stream)
                .forEach(combinedFieldConfig -> fieldObjectMap
                        .put(combinedFieldConfig.getCombinedFieldName(),
                                combinedFieldConfig
                                        .buildValue(fieldObjectMap)));
    }

    private void applyFormat(Map fieldObjectMap) {
        Optional.ofNullable(this.fieldConfig.getFormat())
                .ifPresent(format -> format.forEach(
                        (field, fieldConfigMap) -> JMOptional
                                .getOptional(fieldObjectMap, field)
                                .map(Object::toString)
                                .map(targetString -> buildNestedFieldStringMap(
                                        getFormatMutatorConfig(field,
                                                fieldConfigMap), targetString))
                                .ifPresent(fieldObjectMap::putAll)));
    }

    private MutatorConfigInterface getFormatMutatorConfig(String field,
            Map fieldConfigMap) {
        return JMMap.getOrPutGetNew(this.formatMutatorConfigMap, field,
                () -> buildFieldConfig(fieldConfigMap));
    }

    private MutatorConfigInterface buildFieldConfig(
            Map fieldConfigMap) {
        return ConfigInterface.transformConfig(fieldConfigMap, MutatorConfigType
                .valueOf(fieldConfigMap.get("mutatorConfigType").toString())
                .getConfigClass());
    }

    private Map buildNestedFieldStringMap(
            MutatorConfigInterface mutatorConfig, String targetString) {
        return mutatorConfig.buildMutator().mutate(targetString);
    }

}