| /** |
| * |
| * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation |
| * |
| * |
| * This copyright notice shows up in the generated Java code |
| * |
| */ |
| |
| package org.eclipse.osbp.utils.entityhelper |
| |
| import com.google.inject.Inject |
| import java.util.Date |
| import org.eclipse.emf.ecore.resource.ResourceSet |
| import org.eclipse.osbp.dsl.entity.xtext.extensions.ModelExtensions |
| import org.eclipse.osbp.dsl.semantic.common.types.LDataType |
| import org.eclipse.osbp.dsl.semantic.common.types.LEnum |
| import org.eclipse.osbp.dsl.semantic.common.types.LPackage |
| import org.eclipse.osbp.dsl.semantic.entity.LEntityAttribute |
| import org.eclipse.osbp.ecview.dsl.extensions.TypeHelper |
| import org.eclipse.osbp.ui.api.datamart.IDataMart.EType |
| import org.eclipse.xtext.common.types.JvmEnumerationType |
| import org.eclipse.xtext.common.types.JvmType |
| import org.eclipse.xtext.common.types.access.IJvmTypeProvider |
| import org.eclipse.osbp.dsl.semantic.common.types.LAttribute |
| import org.eclipse.xtext.common.types.JvmTypeReference |
| import org.eclipse.osbp.dsl.semantic.common.types.LDateType |
| import org.eclipse.osbp.runtime.common.layouting.IPropertyConstants |
| |
| public class DataType { |
| |
| @Inject |
| @Extension |
| TypeHelper typeHelper |
| |
| @Inject ModelExtensions entityExtensions |
| |
| @Inject |
| IJvmTypeProvider.Factory typeProviderFactory |
| |
| def public LDataType getLDataType(LAttribute attributeRef) { |
| var type = attributeRef.type |
| var lDataType = null as LDataType |
| if (type instanceof LDataType) { |
| lDataType = type as LDataType |
| } |
| return lDataType |
| } |
| |
| def public JvmType getJvmType(LAttribute attributeRef) { |
| var type = attributeRef.type |
| var lDataType = null as LDataType |
| var ltype = null as JvmType |
| if (type instanceof LDataType) { |
| lDataType = type as LDataType |
| if (lDataType.isDate) { |
| val typeProvider = getTypeProvider(attributeRef.eResource.resourceSet) |
| return typeProvider.findTypeByName(Date.name) |
| } else if (lDataType.isAsBlob) { |
| val typeProvider = getTypeProvider(attributeRef.eResource.resourceSet) |
| return typeProvider.findTypeByName("byte[]") |
| } else { |
| var jvmTypeReference = lDataType.jvmTypeReference |
| ltype = jvmTypeReference.type |
| if (ltype !== null) { |
| return ltype; |
| } |
| } |
| } else if (type instanceof LEnum) { |
| var LPackage pkg = type.eContainer as LPackage |
| val typeProvider = getTypeProvider(attributeRef.eResource.resourceSet) |
| return typeProvider.findTypeByName(pkg.name + "." + type.name) |
| } |
| var JvmTypeReference typeJvm = null |
| if (attributeRef instanceof LEntityAttribute) { |
| typeJvm = entityExtensions.toTypeReference(attributeRef) |
| } else { |
| typeJvm = entityExtensions.toTypeReference(attributeRef) |
| } |
| |
| var typeJvmType = typeJvm.type |
| return typeJvmType |
| } |
| |
| def getTypeProvider(ResourceSet rs) { |
| typeProviderFactory.findOrCreateTypeProvider(rs) |
| } |
| |
| def public EType getBasicType(String typeIdentifier) { |
| if (typeIdentifier !== null) { |
| var identifier = typeIdentifier |
| if (typeIdentifier.startsWith("java.lang.")) { |
| identifier = typeIdentifier.substring("java.lang.".length).toLowerCase |
| } |
| switch (identifier) { |
| /** |
| * Date, String, int, boolean, Time |
| */ |
| case "boolean": return EType.BOOLEAN |
| case "byte": return EType.BYTE |
| case "short": return EType.SHORT |
| case "int": return EType.INTEGER |
| case "integer": return EType.INTEGER |
| case "long": return EType.LONG |
| case "double": return EType.DOUBLE |
| case "float": return EType.FLOAT |
| case "BigDecimal": return EType.DOUBLE |
| case "java.math.BigDecimal": return EType.DOUBLE |
| case "string": return EType.STRING |
| case "java.util.Date": return EType.DATE |
| } |
| } |
| return EType.NONE |
| } |
| |
| def public EType getBasicType(JvmType type) { |
| if (type.boolean) { |
| return EType.BOOLEAN |
| } else if (type.numberWithDigits) { |
| val retcode = getBasicType(type.identifier) |
| if (retcode !== EType.NONE) { |
| return retcode |
| } |
| return EType.DOUBLE |
| } else if (type.numberWithoutDigits) { |
| val retcode = getBasicType(type.identifier) |
| if (retcode !== EType.NONE) { |
| return retcode |
| } |
| return EType.INTEGER |
| } else if (type.string) { |
| return EType.STRING |
| } else if (type.date) { |
| return EType.DATE |
| } else if (type instanceof JvmEnumerationType) { |
| return EType.LENUM; |
| } |
| return getBasicType(type.identifier) |
| } |
| |
| def public EType getBasicType(LAttribute attribute) { |
| var lDataType = getLDataType(attribute) |
| if (lDataType !== null) { |
| if (lDataType.date) { |
| if (lDataType.dateType.equals(LDateType.TIMESTAMP)){ |
| return EType.TIMESTAMP |
| } else if (lDataType.dateType.equals(LDateType.DATE)){ |
| return EType.DATE |
| } else { |
| return EType.DATE |
| } |
| } |
| if (!lDataType.properties.isNullOrEmpty) { |
| // data type is defined as Blob |
| if (getJvmType(attribute).string && lDataType.properties.exists[it.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_BLOB)]){ |
| return EType.BLOPMAPPING |
| } |
| // data type is defined as rich text area |
| if ((getJvmType(attribute).string || lDataType.asBlob) && lDataType.properties.exists[it.value.equalsIgnoreCase(IPropertyConstants.PROPERTY_RICH_TEXT)]){ |
| return EType.RICHTEXTAREA |
| } |
| // data type is defined as checkbox |
| if (getJvmType(attribute).boolean && lDataType.properties.exists[it.value.equalsIgnoreCase(IPropertyConstants.PROPERTY_CHECKBOX)]){ |
| return EType.BOOLEAN_CHECKBOX |
| } |
| } |
| if (!attribute.properties.isNullOrEmpty) { |
| // Otherwise entity attribute is defined as Blob |
| if (getJvmType(attribute).string && attribute.properties.exists[it.key.equalsIgnoreCase(IPropertyConstants.PROPERTY_BLOB)]){ |
| return EType.BLOPMAPPING |
| } |
| // Otherwise entity attribute is defined as rich text area |
| if ((getJvmType(attribute).string || lDataType.asBlob) && attribute.properties.exists[it.value.equalsIgnoreCase(IPropertyConstants.PROPERTY_RICH_TEXT)]){ |
| return EType.RICHTEXTAREA |
| } |
| // data type is defined as rich text area |
| if (getJvmType(attribute).boolean && lDataType.properties.exists[it.value.equalsIgnoreCase(IPropertyConstants.PROPERTY_CHECKBOX)]){ |
| return EType.BOOLEAN_CHECKBOX |
| } |
| } |
| if ("blobMapping".equalsIgnoreCase(lDataType.name)) { |
| return EType.BLOPMAPPING |
| } |
| |
| } |
| return getBasicType(getJvmType(attribute)) |
| } |
| |
| def public EType getBasicType(Class<?> typeClass) { |
| return getBasicType(typeClass.canonicalName) |
| } |
| |
| def public boolean canBeCastFrom(LEntityAttribute targetAttribute, Class<?> sourceClass) { |
| return canBeCastFrom(targetAttribute, getBasicType(sourceClass)) |
| } |
| |
| def public boolean canBeCastFrom(LEntityAttribute targetAttribute, EType sourceType) { |
| var targetType = getBasicType(targetAttribute) |
| |
| switch (targetType) { |
| case BOOLEAN: return (sourceType == EType.BOOLEAN) |
| case BYTE: return (sourceType == EType.BYTE) |
| case DATE: return (sourceType == EType.DATE) |
| case TIMESTAMP: return (sourceType == EType.TIMESTAMP) |
| case FLOAT: return (sourceType == EType.FLOAT || sourceType == EType.LONG || sourceType == EType.INTEGER || |
| sourceType == EType.SHORT || sourceType == EType.BOOLEAN) |
| case DOUBLE: return (sourceType == EType.FLOAT || sourceType == EType.DOUBLE || sourceType == EType.LONG || |
| sourceType == EType.INTEGER || sourceType == EType.SHORT || sourceType == EType.BOOLEAN) |
| case SHORT: return (sourceType == EType.SHORT || sourceType == EType.BOOLEAN) |
| case INTEGER: return (sourceType == EType.INTEGER || sourceType == EType.SHORT || |
| sourceType == EType.BOOLEAN) |
| case LONG: return (sourceType == EType.LONG || sourceType == EType.INTEGER || sourceType == EType.SHORT || |
| sourceType == EType.BOOLEAN) |
| case STRING: return true |
| case TIME: return (sourceType == EType.TIME) |
| case LENUM: return (sourceType == EType.INTEGER || sourceType == EType.BOOLEAN) |
| case NONE: return false |
| } |
| return false |
| } |
| } |
