/** * This method validates Csdl Entity types. * Looks for correct namespace aliases and correct base types */ private void validateCsdlEntityTypes() { for (Map.Entry<FullQualifiedName, CsdlEntityType> entityTypes : csdlEntityTypesMap.entrySet()) { if (entityTypes.getValue() != null && entityTypes.getKey() != null) { CsdlEntityType entityType = entityTypes.getValue(); if (entityType.getBaseType() != null) { CsdlEntityType baseEntityType; FullQualifiedName baseTypeFQName = entityType.getBaseTypeFQN(); if (!csdlEntityTypesMap.containsKey(baseTypeFQName)) { FullQualifiedName fqName = validateCsdlEntityTypeWithAlias(baseTypeFQName); baseEntityType = fetchLastCsdlBaseType(fqName); } else { baseEntityType = fetchLastCsdlBaseType(baseTypeFQName); } if (baseEntityType != null && (baseEntityType.getKey() == null || baseEntityType.getKey().isEmpty())) { throw new RuntimeException("Missing key for EntityType " + baseEntityType.getName()); } } else if (entityType.getKey() == null || entityType.getKey().isEmpty()) { throw new RuntimeException("Missing key for EntityType " + entityType.getName()); } } } }
private void readEntityType(XMLEventReader reader, StartElement element, CsdlSchema schema) throws XMLStreamException { CsdlEntityType entityType = new CsdlEntityType(); entityType.setProperties(new ArrayList<CsdlProperty>()); entityType.setNavigationProperties(new ArrayList<CsdlNavigationProperty>()); entityType.setKey(new ArrayList<CsdlPropertyRef>()); entityType.setName(attr(element, "Name")); if (attr(element, "BaseType") != null) { entityType.setBaseType(new FullQualifiedName(attr(element, "BaseType"))); } entityType.setAbstract(Boolean.parseBoolean(attr(element, "Abstract"))); entityType.setOpenType(Boolean.parseBoolean(attr(element, "OpenType"))); entityType.setHasStream(Boolean.parseBoolean(attr(element, "HasStream"))); readEntityProperties(reader, entityType); schema.getEntityTypes().add(entityType); }
@Override void build(XMLEventReader reader, StartElement element, CsdlEntityType entityType, String name) throws XMLStreamException { if ("Property".equals(name)) { entityType.getProperties().add(readProperty(reader, element)); } else if ("NavigationProperty".equals(name)) { entityType.getNavigationProperties().add(readNavigationProperty(reader, element)); } else if ("Key".equals(name)) { readKey(reader, element, entityType); } else if ("Annotation".equals(name)) { readAnnotations(reader, element, entityType); } } }.read(reader, null, entityType, "Property", "NavigationProperty", "Key", "Annotation");
/** * This fetches the last Base Type entity from a hierarchy of base type derived types * @param baseTypeFQName * @return CsdlEntityType */ private CsdlEntityType fetchLastCsdlBaseType(FullQualifiedName baseTypeFQName) { CsdlEntityType baseEntityType = null; while (baseTypeFQName != null) { if (!(csdlEntityTypesMap.containsKey(baseTypeFQName))) { baseTypeFQName = validateCsdlEntityTypeWithAlias(baseTypeFQName); } baseEntityType = csdlEntityTypesMap.get(baseTypeFQName); if (baseEntityType != null) { if (baseEntityType.getKey() != null) { break; } else if (baseEntityType.getBaseType() != null) { baseTypeFQName = baseEntityType.getBaseTypeFQN(); } else if (baseEntityType.getBaseType() == null) { break; } } } return baseEntityType; }
/** * This fetches the last Base Type entity from a hierarchy of base type derived types * @param baseTypeFQName * @return CsdlNavigationProperty */ private CsdlNavigationProperty fetchLastBaseEntityHavingNavigationProperty( FullQualifiedName baseTypeFQName, String navBindingProperty) { CsdlEntityType baseEntityType = null; while (baseTypeFQName != null) { if (!(csdlEntityTypesMap.containsKey(baseTypeFQName))) { baseTypeFQName = validateCsdlEntityTypeWithAlias(baseTypeFQName); } baseEntityType = csdlEntityTypesMap.get(baseTypeFQName); if (baseEntityType != null) { if (baseEntityType.getNavigationProperty(navBindingProperty) != null) { break; } else if (baseEntityType.getBaseType() != null) { baseTypeFQName = baseEntityType.getBaseTypeFQN(); } else if (baseEntityType.getBaseType() == null) { break; } } } if (baseEntityType == null) { throw new RuntimeException("Entity Type is null with fully qualified name:" + baseTypeFQName); } return baseEntityType.getNavigationProperty(navBindingProperty); }
Map<String, CsdlEntityType> csdlEntityTypesMap = new HashMap<>(); for (String entityTypeName : entityList) { CsdlEntityType entity = new CsdlEntityType(); entity.setName(entityTypeName); for (CsdlProperty property : properties.get(entityTypeName)) { if (EdmPrimitiveTypeKind.Stream.getFullQualifiedName().getFullQualifiedNameAsString() .equals(property.getType())) { entity.setHasStream(true); break; entity.setKey(keys); entity.setProperties(properties.get(entityTypeName)); entity.setNavigationProperties(navigationProperties);
@Override public CsdlEntityType getEntityType(FullQualifiedName name) throws ODataException { if (name.equals(FQN.OBSERVATION)) { return new CsdlEntityType() .setName(FQN.OBSERVATION.getName()) .setKey(Collections.singletonList(newPropertyRef(Prop.IDENTIFIER))) .setOpenType(true) .setProperties(Arrays.asList( newProperty(Prop.IDENTIFIER, FQN.STRING), newProperty(Prop.ID, FQN.STRING),
public final String buildEntitySetName(final CsdlEntityType entityType) { return buildEntitySetName(entityType.getName()); }
FullQualifiedName entityContainerName, CsdlAnnotations annotationGrp, boolean isPropAnnotationsCleared, boolean isNavPropAnnotationsCleared, CsdlEntityType entityType) { for (CsdlProperty propertyName : entityType.getProperties()) { if (!isPropAnnotationsCleared) { entityType.getProperty(propertyName.getName()).getAnnotations().clear(); for (CsdlNavigationProperty navPropertyName : entityType.getNavigationProperties()) { if (!isNavPropAnnotationsCleared) { entityType.getNavigationProperty(navPropertyName.getName()).getAnnotations().clear();
public static EntityTypeModel convertCsdlEntityToCommonModel(CsdlEntityType csdlEntity, String edmxNamespace, CommonJavaObjectForEdmx comModel, CDXEdmProvider edmxMetadataProvider, Map<String, String> namespaceToServMap) { EntityTypeModel entityType = new EntityTypeModel(); entityType.setName(csdlEntity.getName()); entityType.setNamespace(edmxNamespace); // resolve base types String baseTypeName = CsdlBaseTypeResolver.resolveBaseTypesForEntity(csdlEntity, edmxNamespace, comModel, edmxMetadataProvider, namespaceToServMap); entityType.setBaseTypeName(baseTypeName); entityType.setHasBaseType(baseTypeName.equals("") ? false : true); List<PropertyTypeModel> commonProperties = csdlToCommonPropertiesForEntity(entityType, csdlEntity.getProperties(), csdlEntity, comModel, edmxMetadataProvider, namespaceToServMap); entityType.setProperties(commonProperties); List<NavigationTypeModel> navigations = csdlToCommonNavigationsForET(entityType, csdlEntity, edmxNamespace, comModel, namespaceToServMap, edmxMetadataProvider); entityType.setNavigations(navigations); return entityType; }
public static CsdlNavigationProperty findNavigationPropertyFromPath(String path, CsdlEntityType csdlentity, CDXEdmProvider edmxMetadataProvider) { CsdlNavigationProperty navProperty = null; CsdlComplexType complxType = null; if (csdlentity != null) { if (path.contains("/")) { String[] spltdArray = path.split("/"); String navPropName = spltdArray[spltdArray.length-1]; complxType = EdmxToCommonModelHelper.getComplexTypeFromPath(spltdArray[0], csdlentity, edmxMetadataProvider); if (complxType != null) { for (int i = 1; i < spltdArray.length - 1; i++) { complxType = getComplexTypeFromPath(spltdArray[i], complxType, edmxMetadataProvider); } if (complxType != null) { List<CsdlNavigationProperty> navprops = complxType.getNavigationProperties(); navProperty = getNavPropertyFromList(navprops, navPropName); } } } else { List<CsdlNavigationProperty> navprops = csdlentity.getNavigationProperties(); navProperty = getNavPropertyFromList(navprops, path); } } return navProperty; }
@Override void build(XMLEventReader reader, StartElement element, CsdlEntityType entityType, String name) throws XMLStreamException { CsdlPropertyRef ref = new CsdlPropertyRef(); ref.setName(attr(element, "Name")); ref.setAlias(attr(element, "Alias")); entityType.getKey().add(ref); } }.read(reader, element, entityType, "PropertyRef");
void addPrimaryKey(MetadataFactory mf, XMLMetadata metadata, Table table, CsdlEntityType entityType) throws TranslatorException { List<CsdlPropertyRef> keys = entityType.getKey(); List<String> pkNames = new ArrayList<String>(); for (CsdlPropertyRef ref : keys) { if (!addProperty(mf, metadata, table, entityType.getProperty(ref.getName()))) { throw new AssertionError("Complex type not allowed as part of primary key"); //$NON-NLS-1$ } pkNames.add(ref.getName()); if (ref.getAlias() != null) { throw new TranslatorException(ODataPlugin.Util.gs(ODataPlugin.Event.TEIID17018, table.getName(),ref.getName())); } } mf.addPrimaryKey("PK", pkNames, table); }
for (CsdlProperty property : entityType.getProperties()) { if (!addProperty(mf, metadata, table, property)) { complexTypes.add(property); String baseType = entityType.getBaseType(); while (baseType != null) { CsdlEntityType baseEntityType = getEntityType(metadata, baseType); for (CsdlProperty property : baseEntityType.getProperties()) { if (!addProperty(mf, metadata, table, property)) { complexTypes.add(property); baseType = baseEntityType.getBaseType();
/** adds annotations to entity type properties derived from singleton * @param singleton * @param isPropAnnotationsCleared * @param isNavPropAnnotationsCleared * @param entityType * @param annotationGrp */ private void addAnnotationsToPropertiesDerivedFromSingleton(CsdlSingleton singleton, boolean isPropAnnotationsCleared, boolean isNavPropAnnotationsCleared, CsdlEntityType entityType, CsdlAnnotations annotationGrp) { for (CsdlProperty propertyName : entityType.getProperties()) { if (!isPropAnnotationsCleared) { entityType.getProperty(propertyName.getName()).getAnnotations().clear(); } if (isPropertyComplex(propertyName)) { CsdlComplexType complexType = getComplexTypeFromProperty(propertyName); addAnnotationsToComplexTypeIncludedFromSingleton(singleton, annotationGrp, propertyName, isNavPropAnnotationsCleared, complexType); } } }
public static String resolveBaseTypesForEntity(CsdlEntityType csdlEntity, String edmxNamespace, CommonJavaObjectForEdmx comModel, CDXEdmProvider edmxMetadataProvider, Map<String, String> namespaceToServMap) { String baseTypeName = csdlEntity.getBaseType(); // build entity model for base type entity FullQualifiedName fqnEntity = csdlEntity.getBaseTypeFQN(); if (fqnEntity != null) { try { CsdlEntityType csdlBaseEntity = edmxMetadataProvider.getEntityType(fqnEntity); if (!EdmxToCommonModelHelper.isEntityTypeAlreadyParsed(csdlBaseEntity, comModel)) { EntityTypeModel comEntity = EdmxToCommonJavaObjectConverter.convertCsdlEntityToCommonModel( csdlBaseEntity, edmxNamespace, comModel, edmxMetadataProvider, namespaceToServMap); comModel.addEntityType(comEntity); } } catch (ODataException e) { PojoGenUtil.logDebug(log, "Could not fetch Base Type from EdmxProvider called by resolveBaseTypesForEntity"); } } return baseTypeName != null ? baseTypeName : ""; }
public static CsdlComplexType getComplexTypeFromPath(String path, CsdlEntityType csdlentity, CDXEdmProvider edmxMetadataProvider) { FullQualifiedName fqn = null; CsdlComplexType complxType = null; List<CsdlProperty> props = csdlentity.getProperties(); for (int i = 0; i < props.size(); i++) { if (props.get(i).getName().equals(path)) { fqn = props.get(i).getTypeAsFQNObject(); try { complxType = edmxMetadataProvider.getComplexType(fqn); } catch (ODataException e) { PojoGenUtil.logDebug(log, "Could not fetch Complex Type from EdmxProvider called by getComplexTypeFromPath with entity"); } break; } } return complxType; }
CsdlEntityType entityType = new CsdlEntityType().setName(entityTypeName); properties.add(property); entityType.setProperties(properties); if (hasStream(properties)) { entityType.setHasStream(true); entityType.setKey(keyProps); addTableAnnotations(table, entityType, csdlSchema);
public static boolean isEntityTypeAlreadyParsed(CsdlEntityType csdlEntity, CommonJavaObjectForEdmx comJavaObjectForEdmx) { boolean result = false; if (csdlEntity != null && comJavaObjectForEdmx != null) { for (EntityTypeModel entity : comJavaObjectForEdmx.getEntityTypes()) { if (entity.getName().equals(csdlEntity.getName())) { result = true; } } } return result; }
/** * This fetches the last Base Type entity from a hierarchy of base type derived types * @param baseTypeFQName * @return CsdlEntityType */ private CsdlEntityType fetchLastCsdlBaseType(FullQualifiedName baseTypeFQName) { CsdlEntityType baseEntityType = null; while (baseTypeFQName != null) { if (!(csdlEntityTypesMap.containsKey(baseTypeFQName))) { baseTypeFQName = validateCsdlEntityTypeWithAlias(baseTypeFQName); } baseEntityType = csdlEntityTypesMap.get(baseTypeFQName); if (baseEntityType != null) { if (baseEntityType.getKey() != null) { break; } else if (baseEntityType.getBaseType() != null) { baseTypeFQName = baseEntityType.getBaseTypeFQN(); } else if (baseEntityType.getBaseType() == null) { break; } } } return baseEntityType; }