com.flowcentraltech.flowcentral.connect.common.data.EntityInfo Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of flowcentral-connect-common Show documentation
Flowcentral Connect Common Module
The newest version!
/*
 * Copyright 2021-2024 FlowCentral Technologies Limited.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.flowcentraltech.flowcentral.connect.common.data;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.flowcentraltech.flowcentral.connect.configuration.constants.ConnectEntityBaseType;
import com.flowcentraltech.flowcentral.connect.configuration.constants.ConnectFieldDataType;

/**
 * Entity information.
 * 
 * @author FlowCentral Technologies Limited
 * @since 1.0
 */
public class EntityInfo {

    private String entityManagerFactory;

    private String dataSourceAlias;

    private ConnectEntityBaseType baseType;

    private String name;

    private String description;

    private String tableName;

    private String idFieldName;

    private String versionNoFieldName;

    private String handler;

    private String actionPolicy;

    private boolean ignoreOnSync;

    private Class implClass;

    private Map fieldsByName;

    private List refFieldList;

    private List fieldList;

    private List listOnlyFieldList;

    private List childFieldList;

    private List childListFieldList;

    private Map fieldToLocal;

    private Map fieldFromLocal;

    public EntityInfo(String entityManagerFactory, String dataSourceAlias, ConnectEntityBaseType baseType, String name,
            String description, String tableName, String idFieldName, String versionNoFieldName, String handler,
            String actionPolicy, boolean ignoreOnSync, Class implClass, Map fieldsByName) {
        this.entityManagerFactory = entityManagerFactory;
        this.dataSourceAlias = dataSourceAlias;
        this.baseType = baseType;
        this.name = name;
        this.description = description;
        this.tableName = tableName;
        this.idFieldName = idFieldName;
        this.versionNoFieldName = versionNoFieldName;
        this.handler = handler;
        this.actionPolicy = actionPolicy;
        this.ignoreOnSync = ignoreOnSync;
        this.implClass = implClass;
        this.fieldsByName = fieldsByName;
        this.refFieldList = new ArrayList();
        this.fieldList = new ArrayList();
        this.listOnlyFieldList = new ArrayList();
        this.childFieldList = new ArrayList();
        this.childListFieldList = new ArrayList();
        for (EntityFieldInfo entityFieldInfo : fieldsByName.values()) {
            if (entityFieldInfo.isRef()) {
                this.refFieldList.add(entityFieldInfo);
            } else if (entityFieldInfo.isListOnly()) {
                this.listOnlyFieldList.add(entityFieldInfo);
            } else if (entityFieldInfo.isChild()) {
                this.childFieldList.add(entityFieldInfo);
            } else if (entityFieldInfo.isChildList()) {
                this.childListFieldList.add(entityFieldInfo);
            } else {
                this.fieldList.add(entityFieldInfo);
            }
        }

        this.refFieldList = Collections.unmodifiableList(this.refFieldList);
        this.fieldList = Collections.unmodifiableList(this.fieldList);
        this.listOnlyFieldList = Collections.unmodifiableList(this.listOnlyFieldList);
        this.childFieldList = Collections.unmodifiableList(this.childFieldList);
        this.childListFieldList = Collections.unmodifiableList(this.childListFieldList);
        this.fieldToLocal = new HashMap();
        this.fieldFromLocal = new HashMap();
        if (idFieldName != null) {
            this.fieldToLocal.put("id", idFieldName);
            this.fieldFromLocal.put(idFieldName, "id");
        }

        if (versionNoFieldName != null) {
            this.fieldToLocal.put("versionNo", versionNoFieldName);
            this.fieldFromLocal.put(versionNoFieldName, "versionNo");
        }
    }

    public String getEntityManagerFactory() {
        return entityManagerFactory;
    }

    public String getDataSourceAlias() {
        return dataSourceAlias;
    }

    public ConnectEntityBaseType getBaseType() {
        return baseType;
    }

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

    public String getTableName() {
        return tableName;
    }

    public String getIdFieldName() {
        return idFieldName;
    }

    public String getVersionNoFieldName() {
        return versionNoFieldName;
    }

    public boolean isWithVersionNo() {
        return versionNoFieldName != null;
    }

    public String getHandler() {
        return handler;
    }

    public boolean isWithHandler() {
        return handler != null && !handler.trim().isEmpty();
    }

    public String getActionPolicy() {
        return actionPolicy;
    }

    public boolean isWithActionPolicy() {
        return actionPolicy != null && !actionPolicy.trim().isEmpty();
    }

    public boolean isIgnoreOnSync() {
        return ignoreOnSync;
    }

    public Class getImplClass() {
        return implClass;
    }

    public EntityFieldInfo findRefToParent(String parentEntity) {
        // TODO Use map
        for (EntityFieldInfo entityFieldInfo : refFieldList) {
            if (entityFieldInfo.getReferences().equals(parentEntity)) {
                return entityFieldInfo;
            }
        }

        return null;
    }

    public Map getFieldsByName() {
        return fieldsByName;
    }

    public Collection getAllFields() {
        return fieldsByName.values();
    }

    public List getRefFieldList() {
        return refFieldList;
    }

    public List getFieldList() {
        return fieldList;
    }

    public List getListOnlyFieldList() {
        return listOnlyFieldList;
    }

    public List getChildFieldList() {
        return childFieldList;
    }

    public List getChildListFieldList() {
        return childListFieldList;
    }

    public String getLocalFieldName(String fieldName) {
        String local = fieldToLocal.get(fieldName);
        return local != null ? local : fieldName;
    }

    public String getFieldNameFromLocal(String fieldName) {
        String local = fieldFromLocal.get(fieldName);
        return local != null ? local : fieldName;
    }

    public boolean isField(String fieldName) {
        return fieldsByName.containsKey(fieldName);
    }

    public Set getFieldNames() {
        return fieldsByName.keySet();
    }

    public EntityFieldInfo getEntityFieldInfo(String fieldName) throws Exception {
        String local = getLocalFieldName(fieldName);
        EntityFieldInfo entityFieldInfo = fieldsByName.get(local);
        if (entityFieldInfo == null) {
            throw new RuntimeException("Information for field [" + fieldName + "] not found.");
        }

        return entityFieldInfo;
    }

    public static Builder newBuilder(String entityManagerFactory) {
        return new Builder(entityManagerFactory);
    }

    public static class Builder {

        private String entityManagerFactory;

        private String dataSourceAlias;

        private ConnectEntityBaseType baseType;

        private String name;

        private String description;

        private String tableName;

        private String idFieldName;

        private String versionNoFieldName;

        private String handler;

        private String actionPolicy;

        private String implementation;

        private boolean ignoreOnSync;

        private Map fieldsByName;

        public Builder(String entityManagerFactory) {
            this.entityManagerFactory = entityManagerFactory;
            this.fieldsByName = new LinkedHashMap();
        }

        public Builder dataSourceAlias(String dataSourceAlias) {
            this.dataSourceAlias = dataSourceAlias;
            return this;
        }

        public Builder baseType(ConnectEntityBaseType baseType) {
            this.baseType = baseType;
            return this;
        }

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Builder description(String description) {
            this.description = description;
            return this;
        }

        public Builder tableName(String tableName) {
            this.tableName = tableName;
            return this;
        }

        public Builder idFieldName(String idFieldName) {
            this.idFieldName = idFieldName;
            return this;
        }

        public Builder versionNoFieldName(String versionNoFieldName) {
            this.versionNoFieldName = versionNoFieldName;
            return this;
        }

        public Builder handler(String handler) {
            this.handler = handler;
            return this;
        }

        public Builder actionPolicy(String actionPolicy) {
            this.actionPolicy = actionPolicy;
            return this;
        }

        public Builder ignoreOnSync(boolean ignoreOnSync) {
            this.ignoreOnSync = ignoreOnSync;
            return this;
        }

        public Builder implementation(String implementation) {
            this.implementation = implementation;
            return this;
        }

        public Builder addField(ConnectFieldDataType type, Class fieldClass, String fieldName, String description,
                String column) throws Exception {
            return addField(type, fieldClass, fieldName, description, column, null, null, 0, 0, 0, true);
        }

        @SuppressWarnings("unchecked")
        public Builder addField(ConnectFieldDataType type, Class  fieldClass, String fieldName, String description,
                String column, String references, String enumImpl, int precision, int scale, int length,
                boolean nullable) throws Exception {
            if (type == null) {
                throw new RuntimeException("Entity information field type is required");
            }

            if (fieldsByName.containsKey(fieldName)) {
                throw new RuntimeException("Entity information for entity [" + name
                        + "] already contains information for field [" + fieldName + "]");
            }

            if (type.references() && (references == null || references.trim().isEmpty())) {
                throw new RuntimeException(
                        "References property required for entity [" + name + "] field[" + fieldName + "]");
            }

            Class> enumImplClass = enumImpl != null
                    ? (Class>) Class.forName(enumImpl)
                    : null;
            fieldsByName.put(fieldName, new EntityFieldInfo(type, fieldClass, fieldName, description,
                    column, references, enumImplClass, precision, scale, length, nullable));
            return this;
        }

        public EntityInfo build() throws Exception {
            if (baseType == null) {
                throw new RuntimeException("Entity base type is required. Entity name [" + name + "]");
            }

            if (dataSourceAlias == null) {
                throw new RuntimeException("Entity datasource alias is required. Entity name [" + name + "]");
            }

            if (implementation == null) {
                throw new RuntimeException("Entity implementation class name is required. Entity name [" + name + "]");
            }

            Class implClass = Class.forName(implementation);
            return new EntityInfo(entityManagerFactory, dataSourceAlias, baseType, name, description, tableName,
                    idFieldName, versionNoFieldName, handler, actionPolicy, ignoreOnSync, implClass, fieldsByName);
        }
    }

}