file-transformer-base/src/main/java/eu/eudat/file/transformer/entities/descriptiontemplate/FieldEntity.java

package eu.eudat.file.transformer.entities.descriptiontemplate;

import eu.eudat.file.transformer.entities.common.DatabaseViewStyleDefinition;
import eu.eudat.file.transformer.entities.definition.DefinitionSerializable;
import eu.eudat.file.transformer.entities.descriptiontemplate.fielddata.BaseFieldDataEntity;
import eu.eudat.file.transformer.entities.descriptiontemplate.fielddata.FieldDataHelper;
import eu.eudat.file.transformer.entities.xml.XmlBuilder;
import eu.eudat.file.transformer.enums.FieldType;
import eu.eudat.file.transformer.enums.FieldValidationType;
import eu.eudat.file.transformer.model.descriptiontemplatedefinition.Field;
import eu.eudat.file.transformer.model.descriptiontemplatedefinition.Rule;
import eu.eudat.file.transformer.model.descriptiontemplatedefinition.fielddata.BaseFieldData;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import java.util.LinkedList;
import java.util.List;

public class FieldEntity implements DatabaseViewStyleDefinition, DefinitionSerializable<FieldEntity, Field> {
    private String id;
    private int ordinal;
    private List<String> schematics;
    private String numbering;
    private String defaultValue;
    private List<RuleEntity> visibilityRules;
    private BaseFieldDataEntity<BaseFieldDataEntity, BaseFieldData> data;
    private List<FieldValidationType> validations;
    private Boolean includeInExport;

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }

    public int getOrdinal() {
        return ordinal;
    }
    public void setOrdinal(int ordinal) {
        this.ordinal = ordinal;
    }

    public List<String> getSchematics() {
        return schematics;
    }
    public void setSchematics(List<String> schematics) {
        this.schematics = schematics;
    }

    public BaseFieldDataEntity<BaseFieldDataEntity, BaseFieldData> getData() {
        return data;
    }
    public void setData(BaseFieldDataEntity<BaseFieldDataEntity, BaseFieldData> data) {
        this.data = data;
    }

    public String getDefaultValue() {
        return defaultValue;
    }
    public void setDefaultValue(String defaultValue) {
        this.defaultValue = defaultValue;
    }


    public List<FieldValidationType> getValidations() {
        return validations;
    }
    public void setValidations(List<FieldValidationType> validations) {
        this.validations = validations;
    }

    public String getNumbering() {
        return numbering;
    }
    public void setNumbering(String numbering) {
        this.numbering = numbering;
    }

    public Boolean getIncludeInExport() {
        return includeInExport;
    }

    public void setIncludeInExport(Boolean includeInExport) {
        this.includeInExport = includeInExport;
    }

    public List<RuleEntity> getVisibilityRules() {
        return visibilityRules;
    }

    public void setVisibilityRules(List<RuleEntity> visibilityRules) {
        this.visibilityRules = visibilityRules;
    }

    /*@Override
    public Element toXml(Document doc) {
        Element rootElement = doc.createElement("field");
        rootElement.setAttribute("id", this.id);
        rootElement.setAttribute("ordinal", "" + this.ordinal);

        Element schematics = doc.createElement("schematics");
        if (this.schematics != null) {
            for (String s : this.schematics) {
                Element schematic = doc.createElement("schematic");
                schematic.setTextContent(s);
                schematics.appendChild(schematic);
            }
        }

        Element viewStyle = doc.createElement("viewStyle");
        if (this.data != null) {
            switch (this.data.getFieldType()){
                case COMBO_BOX:
                case AUTO_COMPLETE:
                case WORD_LIST:{
                    viewStyle.setAttribute("renderstyle", FieldType.COMBO_BOX.getValue());
                    break;
                }
                case INTERNAL_DMP_ENTRIES:
                case INTERNAL_DMP_ENTRIES_DMPS:
                case INTERNAL_DMP_ENTRIES_DATASETS:
                case INTERNAL_DMP_ENTRIES_RESEARCHERS:{
                    viewStyle.setAttribute("renderstyle", FieldType.INTERNAL_DMP_ENTRIES.getValue());
                    break;
                }
                case BOOLEAN_DECISION: viewStyle.setAttribute("renderstyle", this.data.getFieldType().getValue());
            }
            
        }
        Element visibilityRulesElement = doc.createElement("visible");
        if (this.visibilityRules != null && !this.visibilityRules.isEmpty()) {
            for (RuleEntity rule : this.visibilityRules) {
                visibilityRulesElement.appendChild(rule.toXml(doc));
            }
        }
        Element defaultValue = doc.createElement("defaultValue");
        defaultValue.setAttribute("value", this.getDefaultValue());

        Element validations = doc.createElement("validations");
        for (FieldValidationType validationType : this.validations) {
            Element validation = doc.createElement("validation");
            validation.setAttribute("type", "" + validationType.getValue());
            validations.appendChild(validation);
        }

        Element numbering = doc.createElement("numbering");
        numbering.setTextContent(this.numbering);

        rootElement.appendChild(schematics);
        rootElement.appendChild(numbering);
        rootElement.appendChild(validations);
        rootElement.appendChild(defaultValue);
        rootElement.appendChild(visibilityRulesElement);
        rootElement.appendChild(viewStyle);
        if (this.data != null) {
            rootElement.appendChild(this.data.toXml(doc));
        
        }
        rootElement.setAttribute("export", this.includeInExport == null || this.includeInExport ? "true" : "false");
        return rootElement;
    }*/

    /*@Override
    public FieldEntity fromXml(Element element) {
        this.id = element.getAttribute("id");
        this.ordinal = Integer.parseInt(element.getAttribute("ordinal"));


        Element viewStyle = (Element) XmlBuilder.getNodeFromListByTagName(element.getChildNodes(), "viewStyle");

        FieldType fieldType = FieldType.of(viewStyle.getAttribute("renderstyle"));
        
        Element visibility = (Element) XmlBuilder.getNodeFromListByTagName(element.getChildNodes(), "visible");
        NodeList rulesElements = visibility.getChildNodes();
        this.visibilityRules = new LinkedList();
        for (int temp = 0; temp < rulesElements.getLength(); temp++) {
            Node ruleElement = rulesElements.item(temp);
            if (ruleElement.getNodeType() == Node.ELEMENT_NODE) {
                this.visibilityRules.add(new RuleEntity().fromXml((Element) ruleElement));
            }
        }

        Element numbering = XmlBuilder.getNodeFromListByTagName(element.getChildNodes(), "numbering");
        if (numbering != null) this.numbering = numbering.getTextContent();

        this.schematics = new LinkedList<>();
        Element schematics = (Element) XmlBuilder.getNodeFromListByTagName(element.getChildNodes(), "schematics");
        if(schematics != null){
            NodeList schematicElements = schematics.getChildNodes();
            for (int temp = 0; temp < schematicElements.getLength(); temp++) {
                Node schematicElement = schematicElements.item(temp);
                if (schematicElement.getNodeType() == Node.ELEMENT_NODE) {
                    this.schematics.add(schematicElement.getTextContent());
                }
            }
        }

        Element dataElement = (Element) XmlBuilder.getNodeFromListByTagName(element.getChildNodes(), "data");

        Element defaultValue = (Element) XmlBuilder.getNodeFromListByTagName(element.getChildNodes(), "defaultValue");

        this.defaultValue = defaultValue.getAttribute("value");
        String subType = dataElement != null ? dataElement.getAttribute("type") : null;
        this.data = new FieldDataHelper().create(fieldType, subType);
        if (this.data != null) this.data.fromXml(dataElement);

        this.validations = new LinkedList<>();
        Element validations = (Element) XmlBuilder.getNodeFromListByTagName(element.getChildNodes(), "validations");
        if (validations != null) {
            NodeList validationElements = validations.getChildNodes();
            for (int temp = 0; temp < validationElements.getLength(); temp++) {
                Node validationElement = validationElements.item(temp);
                if (validationElement.getNodeType() == Node.ELEMENT_NODE) {
                    Short enumValue = Short.parseShort(((Element) validationElement).getAttribute("type"));
                    FieldValidationType validationType = FieldValidationType.of(enumValue);
                    this.validations.add(validationType);
                }
            }
        }
        if (element.hasAttribute("export")) {
            this.includeInExport = Boolean.parseBoolean(element.getAttribute("export"));
        } else {
            this.includeInExport = true;
        }
        return this;
    }*/

    @Override
    public FieldEntity fromDefinition(Field object) {
        this.id = object.getId();
        this.ordinal = object.getOrdinal();
        this.visibilityRules = new LinkedList();
        if (object.getVisibilityRules() != null) {
            for (Rule rule : object.getVisibilityRules()) {
                this.visibilityRules.add(new RuleEntity().fromDefinition(rule));
            }
        }

        this.numbering = object.getNumbering();

        this.schematics = new LinkedList<>();
        if(object.getSchematics() != null){
            this.schematics.addAll(object.getSchematics());
        }

        this.defaultValue = object.getDefaultValue();

        FieldType fieldType = switch (object.getData().getFieldType()) {
            case AUTO_COMPLETE, WORD_LIST -> FieldType.COMBO_BOX;
            case INTERNAL_DMP_ENTRIES_DMPS, INTERNAL_DMP_ENTRIES_DATASETS, INTERNAL_DMP_ENTRIES_RESEARCHERS -> FieldType.INTERNAL_DMP_ENTRIES;
            default -> object.getData().getFieldType();
        };
        String subType = object.getData().getFieldType().getValue();
        this.data = (BaseFieldDataEntity<BaseFieldDataEntity, BaseFieldData>) new FieldDataHelper().create(fieldType, subType);
        if (this.data != null) this.data.fromDefinition(object.getData());

        this.validations = new LinkedList<>();
        if (object.getValidations() != null) {
            this.validations.addAll(object.getValidations());
        }
        if (object.getIncludeInExport() != null) {
            this.includeInExport = object.getIncludeInExport();
        } else {
            this.includeInExport = true;
        }
        return this;
    }
}