org.apache.olingo.odata2.api.edm.provider.ComplexType Java Examples

public static void build(final JPAEdmComplexType view) {

    JPAEdmMappingModelAccess mappingModelAccess = view.getJPAEdmMappingModelAccess();
    String jpaEmbeddableTypeName = view.getJPAEmbeddableType().getJavaType().getSimpleName();
    String edmComplexTypeName = null;
    if (mappingModelAccess != null && mappingModelAccess.isMappingModelExists()) {
      edmComplexTypeName = mappingModelAccess.mapJPAEmbeddableType(jpaEmbeddableTypeName);
    }

    if (edmComplexTypeName == null) {
      edmComplexTypeName = jpaEmbeddableTypeName;
    }

    view.getEdmComplexType().setName(edmComplexTypeName);
    ComplexType complexType = view.getEdmComplexType();
    complexType.setName(edmComplexTypeName);
    JPAEdmMapping mapping = new JPAEdmMappingImpl();
    mapping.setJPAType(view.getJPAEmbeddableType().getJavaType());
    complexType.setMapping((Mapping) mapping);

  }
 

@Test
public void testExpandEdmComplexType() {
  ComplexType complexType = new ComplexType();
  List<Property> properties = new ArrayList<Property>();
  JPAEdmMapping mapping1 = new JPAEdmMappingImpl();
  mapping1.setJPAColumnName("LINEITEMID");
  ((Mapping) mapping1).setInternalName("LineItemKey.LiId");
  JPAEdmMapping mapping2 = new JPAEdmMappingImpl();
  mapping2.setJPAColumnName("LINEITEMNAME");
  ((Mapping) mapping2).setInternalName("LineItemKey.LiName");
  properties.add(new SimpleProperty().setName("LIID").setMapping((Mapping) mapping1));
  properties.add(new SimpleProperty().setName("LINAME").setMapping((Mapping) mapping2));
  complexType.setProperties(properties);
  List<Property> expandedList = null;
  try {
    objComplexType.expandEdmComplexType(complexType, expandedList, "SalesOrderItemKey");
  } catch (ClassCastException e) {
    assertTrue(false);
  }
  assertTrue(true);

}
 

@Test
public void facetsTest() throws Exception {
  EntityType employee = aep.getEntityType(new FullQualifiedName(ModelSharedConstants.NAMESPACE_1, "Employee"));
  assertEquals("Employee", employee.getName());
  Property name = getProperty(employee, "EmployeeName");
  assertEquals(Integer.valueOf(20), name.getFacets().getMaxLength());
  assertNull(name.getFacets().getConcurrencyMode());
  assertTrue(name.getFacets().isNullable());
  Property id = getProperty(employee, "EmployeeId");
  assertFalse(id.getFacets().isNullable());

  ComplexType city = aep.getComplexType(new FullQualifiedName(ModelSharedConstants.NAMESPACE_1, "c_City"));
  Property postalCode = getProperty(city.getProperties(), "PostalCode");
  assertEquals(Integer.valueOf(5), postalCode.getFacets().getMaxLength());

  EntityType room = aep.getEntityType(new FullQualifiedName(ModelSharedConstants.NAMESPACE_1, "Room"));
  Property version = getProperty(room, "Version");
  assertEquals(Integer.valueOf(0), version.getFacets().getScale());
  assertEquals(Integer.valueOf(0), version.getFacets().getPrecision());
  assertEquals(EdmConcurrencyMode.Fixed, version.getFacets().getConcurrencyMode());
}
 

@Test
public void complexTypeLocation() throws Exception {
  // validate employee
  EntityType employee = aep.getEntityType(new FullQualifiedName(ModelSharedConstants.NAMESPACE_1, "Employee"));
  final List<Property> properties = employee.getProperties();
  Property location = null;
  for (Property property : properties) {
    if (property.getName().equals("Location")) {
      location = property;
    }
  }
  assertNotNull(location);
  assertEquals("Location", location.getName());

  // validate location complex type
  ComplexType locationType = aep.getComplexType(
      new FullQualifiedName(ModelSharedConstants.NAMESPACE_1, "c_Location"));
  assertEquals("c_Location", locationType.getName());
  assertEquals(2, locationType.getProperties().size());
  assertEquals(false, location.getFacets().isNullable());
}
 

@Before
public void before() throws ODataException {
  EdmProvider edmProvider = mock(EdmProvider.class);

  EntityType entityType = new EntityType().setName("EntityType1");
  when(edmProvider.getEntityType(new FullQualifiedName("EntityType1Ns", "EntityType1"))).thenReturn(entityType);

  ComplexType complexType = new ComplexType().setName("ComplexType1");
  when(edmProvider.getComplexType(new FullQualifiedName("ComplexType1Ns", "ComplexType1"))).thenReturn(complexType);

  Association association = new Association().setName("Association1");
  when(edmProvider.getAssociation(new FullQualifiedName("Association1Ns", "Association1"))).thenReturn(association);

  EntityContainerInfo defaultEntityContainer = new EntityContainerInfo().setName("Container1");
  when(edmProvider.getEntityContainerInfo(null)).thenReturn(defaultEntityContainer);
  when(edmProvider.getEntityContainerInfo("Container1")).thenReturn(defaultEntityContainer);

  edm = new EdmImplProv(edmProvider);

}
 

public void normalizeComplexKey(final ComplexType complexType, final List<PropertyRef> propertyRefList) {
  for (Property property : complexType.getProperties()) {
    try {

      SimpleProperty simpleProperty = (SimpleProperty) property;
      Facets facets = (Facets) simpleProperty.getFacets();
      if (facets == null) {
        simpleProperty.setFacets(new Facets().setNullable(false));
      } else {
        facets.setNullable(false);
      }
      PropertyRef propertyRef = new PropertyRef();
      propertyRef.setName(simpleProperty.getName());
      propertyRefList.add(propertyRef);

    } catch (ClassCastException e) {
      ComplexProperty complexProperty = (ComplexProperty) property;
      normalizeComplexKey(complexTypeView.searchEdmComplexType(complexProperty.getType()), propertyRefList);
    }

  }
}
 

public EdmStructuralTypeImplProv(final EdmImplProv edm, final ComplexType structuralType,
    final EdmTypeKind edmTypeKind, final String namespace) throws EdmException {
  super(edm, structuralType.getName());
  this.structuralType = structuralType;
  this.namespace = namespace;
  this.edmTypeKind = edmTypeKind;

  resolveBaseType();

  buildPropertiesInternal();

  edmProperties = new HashMap<String, EdmTyped>();
}
 

private static List<ComplexType> createComplexTypes() {
  List<ComplexType> complexTypes = new ArrayList<ComplexType>();
  ComplexType complexTypeOne = new ComplexType();
  complexTypeOne.setName(COMPLEX_TYPE_NAME_ONE);
  complexTypeOne.setProperties(createComplexTypePropertiesOne());
  complexTypes.add(complexTypeOne);
  ComplexType complexTypeTwo = new ComplexType();
  complexTypeTwo.setName(COMPLEX_TYPE_NAME_TWO);
  complexTypeTwo.setProperties(createComplexTypePropertiesTwo());
  complexTypes.add(complexTypeTwo);
  return complexTypes;
}
 

@Override
public ComplexType searchEdmComplexType(final String arg0) {
  if (arg0.equals(JPAEdmMockData.ComplexType.ComplexTypeA.class.getName())) {
    return buildComplexTypeA();
  } else if (arg0.equals(JPAEdmMockData.ComplexType.ComplexTypeB.class.getSimpleName())) {
    return buildComplexTypeB();
  }

  return null;

}
 

@Override
public Schema getEdmSchema() {
  Schema schema = new Schema();
  ComplexType complexType = new ComplexType();
  complexType.setName(JPACustomProcessorMock.nonJPAEmbeddableType);
  List<ComplexType> list = new ArrayList<ComplexType>();
  list.add(complexType);
  schema.setComplexTypes(list);

  return schema;

}
 

@Override
public ComplexType searchEdmComplexType(final String arg0) {
  if (arg0.equals(JPACustomProcessorMock.class.getName())) {
    return new ComplexType().setName(JPACustomProcessorMock.edmName);
  } else {
    return null;
  }
}
 

private void validateComplexTypes() throws EntityProviderException {
  for (Map.Entry<FullQualifiedName, ComplexType> complexTypes : complexTypesMap.entrySet()) {
    if (complexTypes.getValue() != null && complexTypes.getKey() != null) {
      ComplexType complexType = complexTypes.getValue();
      if (complexType.getBaseType() != null) {
        FullQualifiedName baseTypeFQName = complexType.getBaseType();
        if (!complexTypesMap.containsKey(baseTypeFQName)) {
          validateComplexTypeWithAlias(baseTypeFQName);
        }
      }
    }
  }
}
 

@Override
public ComplexType getComplexType(final FullQualifiedName edmFQName) throws ODataException {
  for (Schema schema : dataServices.getSchemas()) {
    if (schema.getNamespace().equals(edmFQName.getNamespace())) {
      for (ComplexType complexType : schema.getComplexTypes()) {
        if (complexType.getName().equals(edmFQName.getName())) {
          return complexType;
        }
      }
    }
  }
  return null;
}
 

@Override
protected EdmComplexType createComplexType(final FullQualifiedName fqName) throws ODataException {
  ComplexType complexType = edmProvider.getComplexType(fqName);
  if (complexType == null) {
    return null;
  }
  return new EdmComplexTypeImplProv(this, complexType, fqName.getNamespace());
}
 

@Override
public ComplexType getComplexType(FullQualifiedName edm_fq_name) throws ODataException
{
   if (edm_fq_name != null && edm_fq_name.getNamespace().equals(NAMESPACE))
   {
      return COMPLEX_TYPES.get(edm_fq_name.getName());
   }
   return null;
}
 

@BeforeClass
public static void setup() throws Exception {

  edmProvider = mock(EdmProvider.class);
  EdmImplProv edmImplProv = new EdmImplProv(edmProvider);

  Mapping propertySimpleMapping = new Mapping().setInternalName("value");
  CustomizableFeedMappings propertySimpleFeedMappings = new CustomizableFeedMappings().setFcKeepInContent(true);
  SimpleProperty propertySimple =
      new SimpleProperty().setName("PropertyName").setType(EdmSimpleTypeKind.String)
          .setMimeType("mimeType").setMapping(propertySimpleMapping).setCustomizableFeedMappings(
              propertySimpleFeedMappings);
  propertySimpleProvider = new EdmSimplePropertyImplProv(edmImplProv, propertySimple);

  Facets facets = new Facets().setNullable(false);
  SimpleProperty propertySimpleWithFacets =
      new SimpleProperty().setName("PropertyName").setType(EdmSimpleTypeKind.String).setFacets(facets);
  propertySimpleWithFacetsProvider = new EdmSimplePropertyImplProv(edmImplProv, propertySimpleWithFacets);

  Facets facets2 = new Facets().setNullable(true);
  SimpleProperty propertySimpleWithFacets2 =
      new SimpleProperty().setName("PropertyName").setType(EdmSimpleTypeKind.String).setFacets(facets2);
  propertySimpleWithFacetsProvider2 = new EdmSimplePropertyImplProv(edmImplProv, propertySimpleWithFacets2);

  ComplexType complexType = new ComplexType().setName("complexType");
  FullQualifiedName complexName = new FullQualifiedName("namespace", "complexType");
  when(edmProvider.getComplexType(complexName)).thenReturn(complexType);

  ComplexProperty propertyComplex = new ComplexProperty().setName("complexProperty").setType(complexName);
  propertyComplexProvider = new EdmComplexPropertyImplProv(edmImplProv, propertyComplex);

}
 

@BeforeClass
public static void getEdmEntityContainerImpl() throws Exception {

  edmProvider = mock(EdmProvider.class);
  EdmImplProv edmImplProv = new EdmImplProv(edmProvider);

  ComplexType fooComplexType = new ComplexType().setName("fooComplexType");

  List<Property> keyPropertysFoo = new ArrayList<Property>();
  keyPropertysFoo.add(new SimpleProperty().setName("Name").setType(EdmSimpleTypeKind.String));
  keyPropertysFoo.add(new SimpleProperty().setName("Address").setType(EdmSimpleTypeKind.String));
  fooComplexType.setProperties(keyPropertysFoo);

  edmComplexType = new EdmComplexTypeImplProv(edmImplProv, fooComplexType, "namespace");

  FullQualifiedName barBaseTypeName = new FullQualifiedName("namespace", "barBase");
  ComplexType barBase = new ComplexType().setName("barBase");
  when(edmProvider.getComplexType(barBaseTypeName)).thenReturn(barBase);

  List<Property> propertysBarBase = new ArrayList<Property>();
  propertysBarBase.add(new SimpleProperty().setName("Name").setType(EdmSimpleTypeKind.String));
  propertysBarBase.add(new SimpleProperty().setName("Address").setType(EdmSimpleTypeKind.String));
  barBase.setProperties(propertysBarBase);

  ComplexType barComplexType = new ComplexType().setName("barComplexType").setBaseType(barBaseTypeName);
  edmComplexTypeWithBaseType = new EdmComplexTypeImplProv(edmImplProv, barComplexType, "namespace");

}
 

@Before
public void getEdmImpl() throws Exception {
  EdmProvider edmProvider = mock(EdmProvider.class);

  List<AliasInfo> aliasInfos = new ArrayList<AliasInfo>();

  EntityType entityType = new EntityType().setName("EntityType1");
  when(edmProvider.getEntityType(new FullQualifiedName("EntityType1Ns", "EntityType1"))).thenReturn(entityType);
  AliasInfo aliasInfo1 = new AliasInfo().setAlias("et1").setNamespace("EntityType1Ns");
  aliasInfos.add(aliasInfo1);

  ComplexType complexType = new ComplexType().setName("ComplexType1");
  when(edmProvider.getComplexType(new FullQualifiedName("ComplexType1Ns", "ComplexType1"))).thenReturn(complexType);
  AliasInfo aliasInfo2 = new AliasInfo().setAlias("ct1").setNamespace("ComplexType1Ns");
  aliasInfos.add(aliasInfo2);

  Association association = new Association().setName("Association1");
  when(edmProvider.getAssociation(new FullQualifiedName("Association1Ns", "Association1"))).thenReturn(association);
  AliasInfo aliasInfo3 = new AliasInfo().setAlias("at1").setNamespace("Association1Ns");
  aliasInfos.add(aliasInfo3);

  when(edmProvider.getAliasInfos()).thenReturn(aliasInfos);

  EntityContainerInfo defaultEntityContainer = new EntityContainerInfo().setName("Container1");
  when(edmProvider.getEntityContainerInfo(null)).thenReturn(defaultEntityContainer);
  when(edmProvider.getEntityContainerInfo("Container1")).thenReturn(defaultEntityContainer);

  edm = new EdmImplProv(edmProvider);
}
 

@Override
public ComplexType getComplexType(final FullQualifiedName edmFQName) throws ODataException {
  if (NAMESPACE.equals(edmFQName.getNamespace())) {
    if (COMPLEX_TYPE.getName().equals(edmFQName.getName())) {
      List<Property> properties = new ArrayList<Property>();
      properties.add(new SimpleProperty().setName("Street").setType(EdmSimpleTypeKind.String));
      properties.add(new SimpleProperty().setName("City").setType(EdmSimpleTypeKind.String));
      properties.add(new SimpleProperty().setName("ZipCode").setType(EdmSimpleTypeKind.String));
      properties.add(new SimpleProperty().setName("Country").setType(EdmSimpleTypeKind.String));
      return new ComplexType().setName(COMPLEX_TYPE.getName()).setProperties(properties);
    }
  }

  return null;
}
 

private List<ComplexType> describeTypes() {
	List<ComplexType> types = new ArrayList<>();
	for (Entry<Class<?>, String> odataType : CLASS_TYPES.entrySet()) {
		try {
			types.add(describeType(odataType.getKey(), odataType.getValue()));
		} catch (SecurityException | IllegalArgumentException | InstantiationException | IllegalAccessException | NoSuchFieldException
				| IntrospectionException ex) {
			throw new IllegalStateException("Invalid OData configuration!", ex); //$NON-NLS-1$
		}
	}
	return types;
}
 

private ComplexType describeType(Class<?> odataType, String name) throws SecurityException, IllegalArgumentException, InstantiationException,
		IllegalAccessException, IntrospectionException, NoSuchFieldException {
	List<Field> fields = getTypeFields(odataType);

	List<Property> properties = new ArrayList<>();
	for (Field field : fields) {
		properties.add(createProperty(field));
	}

	ComplexType complexType = new ComplexType();
	complexType.setName(name);
	complexType.setProperties(properties);

	return complexType;
}
 

@Override
public ComplexType getComplexType(FullQualifiedName edmFQName) throws ODataException {
    if (NAMESPACE.equals(edmFQName.getNamespace())) {
        if (COMPLEX_TYPE.getName().equals(edmFQName.getName())) {
            List<Property> properties = new ArrayList<>();
            properties.add(new SimpleProperty().setName("Street").setType(EdmSimpleTypeKind.String));
            properties.add(new SimpleProperty().setName("City").setType(EdmSimpleTypeKind.String));
            properties.add(new SimpleProperty().setName("ZipCode").setType(EdmSimpleTypeKind.String));
            properties.add(new SimpleProperty().setName("Country").setType(EdmSimpleTypeKind.String));
            return new ComplexType().setName(COMPLEX_TYPE.getName()).setProperties(properties);
        }
    }

    return null;
}
 

private static List<ComplexType> getComplexTypes()
{
   List<ComplexType> complexTypeList = new ArrayList<>();

   // Defines complex type TimeRange
   List<Property> timeRangeProperties = new ArrayList<>();
   timeRangeProperties.add(
         new SimpleProperty()
               .setName(TIME_RANGE_START)
               .setType(EdmSimpleTypeKind.DateTime));
   timeRangeProperties.add(
         new SimpleProperty()
               .setName(TIME_RANGE_END)
               .setType(EdmSimpleTypeKind.DateTime));
   complexTypeList.add(
         new ComplexType()
               .setName(TIME_RANGE.getName())
               .setProperties(timeRangeProperties));

   // Defines complex type Checksum
   List<Property> checksumProperties = new ArrayList<>();
   checksumProperties.add(
         new SimpleProperty()
               .setName(ALGORITHM)
               .setType(EdmSimpleTypeKind.String));
   checksumProperties.add(
         new SimpleProperty()
               .setName(VALUE)
               .setType(EdmSimpleTypeKind.String));
   complexTypeList.add(
         new ComplexType()
               .setName(CHECKSUM.getName())
               .setProperties(checksumProperties));

   return complexTypeList;
}
 

@Override
public ComplexType getComplexType(final FullQualifiedName edmFQName) throws ODataException {

  if (edmFQName != null) {
    if (complexTypes.containsKey(edmFQName.toString())) {
      return complexTypes.get(edmFQName.toString());
    } else if (schemas == null) {
      getSchemas();
    }

    for (Schema schema : schemas) {
      if (schema.getNamespace().equals(edmFQName.getNamespace())) {
        if (schema.getComplexTypes() == null) {
          return null;
        }
        for (ComplexType ct : schema.getComplexTypes()) {
          if (ct.getName().equals(edmFQName.getName())) {
            complexTypes.put(edmFQName.toString(), ct);
            return ct;
          }
        }
      }
    }
  }

  return null;
}
 

public ODataJPAEdmProvider(final ODataJPAContext oDataJPAContext) {
  if (oDataJPAContext == null) {
    throw new IllegalArgumentException(ODataJPAException.ODATA_JPACTX_NULL);
  }
  entityTypes = new LinkedHashMap<String, EntityType>();
  entityContainerInfos = new LinkedHashMap<String, EntityContainerInfo>();
  complexTypes = new LinkedHashMap<String, ComplexType>();
  associations = new LinkedHashMap<String, Association>();
  functionImports = new LinkedHashMap<String, FunctionImport>();
  jpaEdmModel = ODataJPAFactory.createFactory().getJPAAccessFactory().getJPAEdmModelView(oDataJPAContext);
}
 

private ComplexType searchComplexTypeByName(final String name) {
  for (ComplexType complexType : consistentComplextTypes) {
    if (null != complexType && null != complexType.getName() && complexType.getName().equals(name)) {
      return complexType;
    }
  }

  return null;
}
 

public ODataJPAEdmProvider() {
  entityTypes = new LinkedHashMap<String, EntityType>();
  entityContainerInfos = new LinkedHashMap<String, EntityContainerInfo>();
  complexTypes = new LinkedHashMap<String, ComplexType>();
  associations = new LinkedHashMap<String, Association>();
  functionImports = new LinkedHashMap<String, FunctionImport>();
}
 

@Test
public void defaultNamespaceGenerationComplexType() throws ODataException {
  Collection<Class<?>> localAnnotatedClasses = new ArrayList<Class<?>>();
  localAnnotatedClasses.add(GeneratedNamesComplexTestClass.class);
  AnnotationEdmProvider localAep = new AnnotationEdmProvider(localAnnotatedClasses);
  // validate
  ComplexType testType = localAep.getComplexType(new FullQualifiedName(
      GeneratedNamesComplexTestClass.class.getPackage().getName(),
      GeneratedNamesComplexTestClass.class.getSimpleName()));
  assertNotNull("Requested entity not found.", testType);
  assertEquals("GeneratedNamesComplexTestClass", testType.getName());
  assertNull("This should not have a base type", testType.getBaseType());
}
 

@Test
public void defaultNameAndNamespaceGeneration() throws ODataException {
  Collection<Class<?>> localAnnotatedClasses = new ArrayList<Class<?>>();
  localAnnotatedClasses.add(GeneratedNamesTestClass.class);
  localAnnotatedClasses.add(GeneratedNamesComplexTestClass.class);
  AnnotationEdmProvider localAep = new AnnotationEdmProvider(localAnnotatedClasses);
  // validate
  EntityType testType = localAep.getEntityType(new FullQualifiedName(
      GeneratedNamesTestClass.class.getPackage().getName(),
      GeneratedNamesTestClass.class.getSimpleName()));
  assertNotNull("Requested entity not found.", testType);
  assertEquals("GeneratedNamesTestClass", testType.getName());
  assertNull("This should not have a base type", testType.getBaseType());
  List<Property> properties = testType.getProperties();
  assertEquals(1, properties.size());
  ComplexProperty propComplex = (ComplexProperty) properties.get(0);
  assertEquals("MyComplexProperty", propComplex.getName());
  assertEquals(GeneratedNamesComplexTestClass.class.getPackage().getName(), propComplex.getType().getNamespace());
  assertEquals(GeneratedNamesComplexTestClass.class.getSimpleName(), propComplex.getType().getName());


  ComplexType testComplexType = localAep.getComplexType(
      new FullQualifiedName(GeneratedNamesComplexTestClass.class.getPackage().getName(),
          GeneratedNamesComplexTestClass.class.getSimpleName()));
  assertNotNull("Requested entity not found.", testComplexType);
  assertEquals("GeneratedNamesComplexTestClass", testComplexType.getName());
  assertNull("This should not have a base type", testComplexType.getBaseType());
}
 

public ComplexType buildComplexType() {
  ComplexType complexType = new ComplexType();
  if (baseEntityType != null) {
    complexType.setBaseType(baseEntityType);
  }
  return complexType.setName(name).setProperties(properties);
}