| /** |
| * 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.xtext.table.generator; |
| |
| import java.io.StringWriter; |
| import java.io.Writer; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.function.Consumer; |
| import javax.inject.Inject; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.ecore.xmi.XMLResource; |
| import org.eclipse.emf.ecore.xmi.impl.XMLResourceImpl; |
| import org.eclipse.osbp.dsl.semantic.common.types.LAttribute; |
| import org.eclipse.osbp.dsl.semantic.common.types.LClass; |
| import org.eclipse.osbp.dsl.semantic.common.types.LDataType; |
| import org.eclipse.osbp.dsl.semantic.common.types.LPackage; |
| import org.eclipse.osbp.dsl.semantic.common.types.LScalarType; |
| import org.eclipse.osbp.dsl.semantic.common.types.LType; |
| import org.eclipse.osbp.dsl.semantic.dto.LDto; |
| import org.eclipse.osbp.dsl.semantic.dto.LDtoAbstractAttribute; |
| import org.eclipse.osbp.dsl.semantic.dto.LDtoInheritedAttribute; |
| import org.eclipse.osbp.dsl.semantic.entity.LBean; |
| import org.eclipse.osbp.dsl.semantic.entity.LBeanAttribute; |
| import org.eclipse.osbp.ecview.dsl.extensions.TypeHelper; |
| import org.eclipse.osbp.infogrid.model.gridsource.CxGridProperty; |
| import org.eclipse.osbp.infogrid.model.gridsource.CxGridSourceFactory; |
| import org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropPriceStyle; |
| import org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropQuantityStyle; |
| import org.eclipse.osbp.infogrid.model.gridsource.style.CxGridPropStyle; |
| import org.eclipse.osbp.infogrid.model.gridsource.style.CxGridStyleFactory; |
| import org.eclipse.osbp.infogrid.model.gridsource.util.Util; |
| import org.eclipse.osbp.xtext.table.Table; |
| import org.eclipse.osbp.xtext.table.TableDtoDatasource; |
| import org.eclipse.osbp.xtext.table.TableGrid; |
| import org.eclipse.osbp.xtext.table.TableModel; |
| import org.eclipse.osbp.xtext.table.TableOption; |
| import org.eclipse.osbp.xtext.table.TablePackage; |
| import org.eclipse.xtend2.lib.StringConcatenation; |
| import org.eclipse.xtext.common.types.JvmType; |
| import org.eclipse.xtext.common.types.JvmTypeReference; |
| import org.eclipse.xtext.generator.IFileSystemAccess; |
| import org.eclipse.xtext.generator.IGenerator; |
| import org.eclipse.xtext.naming.IQualifiedNameProvider; |
| import org.eclipse.xtext.xbase.lib.CollectionLiterals; |
| import org.eclipse.xtext.xbase.lib.Conversions; |
| import org.eclipse.xtext.xbase.lib.Exceptions; |
| import org.eclipse.xtext.xbase.lib.Extension; |
| |
| /** |
| * Generates code from your model files on save. |
| * |
| * see http://www.eclipse.org/Xtext/documentation.html#TutorialCodeGeneration |
| */ |
| @SuppressWarnings("all") |
| public class TableGridSourceGenerator implements IGenerator { |
| @Inject |
| @Extension |
| private IQualifiedNameProvider _iQualifiedNameProvider; |
| |
| @Inject |
| @Extension |
| private TypeHelper _typeHelper; |
| |
| @Override |
| public void doGenerate(final Resource resource, final IFileSystemAccess fsa) { |
| this.toBinary(resource, fsa); |
| } |
| |
| public void toBinary(final Resource input, final IFileSystemAccess fsa) { |
| EObject _get = input.getContents().get(0); |
| final TableModel lModel = ((TableModel) _get); |
| final Consumer<TablePackage> _function = (TablePackage it) -> { |
| final String packageName = it.getName(); |
| final Consumer<Table> _function_1 = (Table it_1) -> { |
| final String tableName = it_1.getName(); |
| TableOption _tabletype = it_1.getTabletype(); |
| if ((_tabletype instanceof TableGrid)) { |
| TableOption _tabletype_1 = it_1.getTabletype(); |
| this.generateXMI(((TableGrid) _tabletype_1), packageName, tableName, fsa); |
| } |
| }; |
| it.getTables().forEach(_function_1); |
| }; |
| lModel.getPackages().forEach(_function); |
| } |
| |
| public void generateXMI(final TableGrid grid, final String packageName, final String tableName, final IFileSystemAccess fsa) { |
| try { |
| final XMLResource outputRes = new XMLResourceImpl(); |
| final TableDtoDatasource ds = grid.getSource(); |
| ds.setId((((packageName + ".") + tableName) + "Grid")); |
| StringConcatenation _builder = new StringConcatenation(); |
| EObject _eContainer = ds.getDtoSource().eContainer(); |
| String _name = ((LPackage) _eContainer).getName(); |
| _builder.append(_name); |
| _builder.append("."); |
| String _name_1 = ds.getDtoSource().getName(); |
| _builder.append(_name_1); |
| ds.setRootTypeFQN(_builder.toString()); |
| if (((ds.getProperties() != null) && (((Object[])Conversions.unwrapArray(ds.getProperties(), Object.class)).length > 0))) { |
| EList<CxGridProperty> _properties = ds.getProperties(); |
| for (final CxGridProperty prop : _properties) { |
| { |
| prop.setDotPath(Util.calcDotPath(prop)); |
| prop.setSourceFQN(this._iQualifiedNameProvider.getFullyQualifiedName(prop.getPath().getField().eContainer()).toString()); |
| this.prepare(prop.getStyle()); |
| } |
| } |
| } else { |
| HashMap<String, String> attributesMap = CollectionLiterals.<String, String>newHashMap(); |
| HashMap<String, LScalarType> attributesTypeMap = CollectionLiterals.<String, LScalarType>newHashMap(); |
| HashMap<String, String> attributesSourceMap = CollectionLiterals.<String, String>newHashMap(); |
| String sourceFQN = this._iQualifiedNameProvider.getFullyQualifiedName(ds.getDtoSource()).toString(); |
| List<LDtoAbstractAttribute> _attributes = ds.getDtoSource().getAttributes(); |
| for (final LDtoAbstractAttribute attr : _attributes) { |
| boolean _allowedAttribute = this.allowedAttribute(ds, attr); |
| if (_allowedAttribute) { |
| this.fillAttributes(attr, sourceFQN, attributesMap, attributesTypeMap, attributesSourceMap); |
| } |
| } |
| LDto _superType = ds.getDtoSource().getSuperType(); |
| boolean _tripleNotEquals = (_superType != null); |
| if (_tripleNotEquals) { |
| sourceFQN = this._iQualifiedNameProvider.getFullyQualifiedName(ds.getDtoSource().getSuperType()).toString(); |
| List<LDtoAbstractAttribute> _attributes_1 = ds.getDtoSource().getSuperType().getAttributes(); |
| for (final LDtoAbstractAttribute attr_1 : _attributes_1) { |
| boolean _allowedAttribute_1 = this.allowedAttribute(ds, attr_1); |
| if (_allowedAttribute_1) { |
| this.fillAttributes(attr_1, sourceFQN, attributesMap, attributesTypeMap, attributesSourceMap); |
| } |
| } |
| } |
| Set<String> _keySet = attributesMap.keySet(); |
| for (final String attrKey : _keySet) { |
| { |
| CxGridProperty prop_1 = CxGridSourceFactory.eINSTANCE.createCxGridProperty(); |
| prop_1.setDotPath(attributesMap.get(attrKey)); |
| prop_1.setStyle(this.getPropStyle(attributesTypeMap.get(attrKey))); |
| sourceFQN = attributesSourceMap.get(attrKey); |
| if ((sourceFQN == null)) { |
| sourceFQN = ds.getRootTypeFQN(); |
| } |
| prop_1.setSourceFQN(sourceFQN); |
| prop_1.setEditable(true); |
| ds.getProperties().add(prop_1); |
| } |
| } |
| } |
| final TableDtoDatasource copy = EcoreUtil.<TableDtoDatasource>copy(ds); |
| EList<EObject> _contents = outputRes.getContents(); |
| _contents.add(copy); |
| final Writer writer = new StringWriter(); |
| outputRes.save(writer, null); |
| String _id = ds.getId(); |
| String _plus = (_id + ".gridsource_xmi"); |
| fsa.generateFile(_plus, "xmi", writer.toString()); |
| } catch (Throwable _e) { |
| throw Exceptions.sneakyThrow(_e); |
| } |
| } |
| |
| protected boolean allowedAttribute(final TableDtoDatasource ds, final LDtoAbstractAttribute attr) { |
| boolean _xblockexpression = false; |
| { |
| boolean allowedAttr = true; |
| LAttribute attribute = attr; |
| if ((attr instanceof LDtoInheritedAttribute)) { |
| attribute = ((LDtoInheritedAttribute) attr).getInheritedFeature(); |
| } |
| LType wrappedType = ds.getDtoSource().getWrappedType(); |
| if ((wrappedType instanceof LClass)) { |
| allowedAttr = ((LClass) wrappedType).isNormalAttribute(attribute); |
| } |
| _xblockexpression = allowedAttr; |
| } |
| return _xblockexpression; |
| } |
| |
| public CxGridPropStyle getPropStyle(final LScalarType type) { |
| if ((type instanceof LDataType)) { |
| boolean _isDate = ((LDataType)type).isDate(); |
| if (_isDate) { |
| return CxGridStyleFactory.eINSTANCE.createCxGridPropDateStyle(); |
| } else { |
| boolean _isAsBlob = ((LDataType)type).isAsBlob(); |
| if (_isAsBlob) { |
| return CxGridStyleFactory.eINSTANCE.createCxGridPropTextStyle(); |
| } else { |
| JvmTypeReference _jvmTypeReference = ((LDataType) type).getJvmTypeReference(); |
| JvmType _type = null; |
| if (_jvmTypeReference!=null) { |
| _type=_jvmTypeReference.getType(); |
| } |
| JvmType jvmType = _type; |
| if ((jvmType != null)) { |
| boolean _isString = this._typeHelper.isString(jvmType); |
| if (_isString) { |
| return CxGridStyleFactory.eINSTANCE.createCxGridPropTextStyle(); |
| } else { |
| boolean _isBoolean = this._typeHelper.isBoolean(jvmType); |
| if (_isBoolean) { |
| return CxGridStyleFactory.eINSTANCE.createCxGridPropBooleanStyle(); |
| } else { |
| boolean _isDate_1 = this._typeHelper.isDate(jvmType); |
| if (_isDate_1) { |
| return CxGridStyleFactory.eINSTANCE.createCxGridPropDateStyle(); |
| } else { |
| boolean _isNumber = this._typeHelper.isNumber(jvmType); |
| if (_isNumber) { |
| return CxGridStyleFactory.eINSTANCE.createCxGridPropNumberStyle(); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return CxGridStyleFactory.eINSTANCE.createCxGridPropTextStyle(); |
| } |
| |
| public void fillAttributes(final LDtoAbstractAttribute attr, final String sourceFQN, final HashMap<String, String> attributesMap, final HashMap<String, LScalarType> attributesTypeMap, final HashMap<String, String> attributesSourceMap) { |
| LAttribute attribute = attr; |
| if ((attr instanceof LDtoInheritedAttribute)) { |
| attribute = ((LDtoInheritedAttribute) attr).getInheritedFeature(); |
| } |
| LScalarType _type = attribute.getType(); |
| LScalarType type = ((LScalarType) _type); |
| this.recurseAttributesMap(sourceFQN, type, attribute, attributesMap, attributesTypeMap, attributesSourceMap); |
| } |
| |
| protected void _prepare(final CxGridPropStyle style) { |
| } |
| |
| protected void _prepare(final CxGridPropPriceStyle style) { |
| style.setValuePropertyDotPath(Util.calcDotPath(style.getValuePropertyPath())); |
| style.setCurrencyPropertyDotPath(Util.calcDotPath(style.getCurrencyPropertyPath())); |
| } |
| |
| protected void _prepare(final CxGridPropQuantityStyle style) { |
| style.setValuePropertyDotPath(Util.calcDotPath(style.getValuePropertyPath())); |
| style.setUomPropertyDotPath(Util.calcDotPath(style.getUomPropertyPath())); |
| } |
| |
| public void recurseAttributesMap(final String sourceFQN, final LScalarType type, final LAttribute attribute, final Map<String, String> attributesMap, final HashMap<String, LScalarType> attributesTypeMap, final HashMap<String, String> attributesSourceMap) { |
| if (((type != null) && (type instanceof LBean))) { |
| LBean bean = ((LBean) type); |
| List<LBeanAttribute> _allAttributes = bean.getAllAttributes(); |
| for (final LBeanAttribute attr : _allAttributes) { |
| LScalarType _type = attr.getType(); |
| if ((_type instanceof LBean)) { |
| this.recurseAttributesMap(sourceFQN, attr.getType(), attribute, attributesMap, attributesTypeMap, attributesSourceMap); |
| } else { |
| this.fillAttributeMaps(attr, sourceFQN, attribute.getName(), attributesMap, attributesTypeMap, attributesSourceMap); |
| } |
| } |
| } else { |
| this.fillAttributeMaps(attribute, sourceFQN, attributesMap, attributesTypeMap, attributesSourceMap); |
| } |
| } |
| |
| public void fillAttributeMaps(final LAttribute attr, final String sourceFQN, final Map<String, String> attributesMap, final HashMap<String, LScalarType> attributesTypeMap, final HashMap<String, String> attributesSourceMap) { |
| this.fillAttributeMaps(attr, sourceFQN, null, attributesMap, attributesTypeMap, attributesSourceMap); |
| } |
| |
| public void fillAttributeMaps(final LAttribute attr, final String sourceFQN, final String attributeBeanName, final Map<String, String> attributesMap, final HashMap<String, LScalarType> attributesTypeMap, final HashMap<String, String> attributesSourceMap) { |
| String attrName = attr.getName(); |
| if ((attributeBeanName != null)) { |
| StringConcatenation _builder = new StringConcatenation(); |
| _builder.append(attributeBeanName); |
| _builder.append("."); |
| _builder.append(attrName); |
| attrName = _builder.toString(); |
| } |
| attributesMap.put(attr.getName(), attrName); |
| attributesTypeMap.put(attr.getName(), attr.getType()); |
| attributesSourceMap.put(attr.getName(), sourceFQN); |
| } |
| |
| public void prepare(final CxGridPropStyle style) { |
| if (style instanceof CxGridPropPriceStyle) { |
| _prepare((CxGridPropPriceStyle)style); |
| return; |
| } else if (style instanceof CxGridPropQuantityStyle) { |
| _prepare((CxGridPropQuantityStyle)style); |
| return; |
| } else if (style != null) { |
| _prepare(style); |
| return; |
| } else { |
| throw new IllegalArgumentException("Unhandled parameter types: " + |
| Arrays.<Object>asList(style).toString()); |
| } |
| } |
| } |
