Java CsdlEntitySet类代码示例

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Test
public void test_JpaEntityCsdlProvider_getCsdlEntitySet_returnsWhatDefined() throws CsdlExtractException {

    // GIVEN
    final JpaEntityCsdlProvider sut = new TestCsdlEntityProvider();

    // WHEN
    CsdlEntitySet result = sut.getCsdlEntitySet();
    List<CsdlNavigationPropertyBinding> bindings = result.getNavigationPropertyBindings();

    // THEN
    assertThat(result.getName()).isEqualTo(SET_1);
    assertThat(result.getTypeFQN().getNamespace()).isEqualTo(FullQualifiedNamesUtil.NAMESPACE.ENTITIES);
    assertThat(bindings).hasSize(2);
    assertThat(bindings.get(0).getTarget()).isEqualTo(SET_2);
    assertThat(bindings.get(0).getPath()).isEqualTo(NESTED_FIELD);
    assertThat(bindings.get(1).getPath()).isEqualTo(SET_2);
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Override
public CsdlEntitySet getEntitySet(FullQualifiedName entityContainer, final String name) throws ODataException {

	try {
		//for (CsdlSchema schema : this.rdfEdmModelProvider.getEdmMetadata().getSchemas()) {
			CsdlEntityContainer schemaEntityContainer = this.rdfEdmModelProvider.getEdmMetadata().getSchema(entityContainer.getNamespace()).getEntityContainer();
			//if (entityContainer.equals(schemaEntityContainer.getName())) {
				for (CsdlEntitySet entitySet : schemaEntityContainer.getEntitySets()) {
					if (name.equals(entitySet.getName())) {
						return entitySet;
					}
				}

			//}
	//	}
	} catch (NullPointerException e) {
		log.error("NullPointerException getEntitySet " + entityContainer + " " + name);
		throw new ODataException("NullPointerException getEntitySet " + entityContainer + " " + name);
	}
	return null;
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Override
public CsdlEntityContainer getEntityContainer() throws ODataException {
    // create EntityContainer
    CsdlEntityContainer entityContainer = new CsdlEntityContainer();
    entityContainer.setName(getContainerName().getName());

    List<CsdlSchema> schemas = getSchemas();
    for (CsdlSchema schema : schemas) {
        for (CsdlEntitySet entitySet : schema.getEntityContainer().getEntitySets()) {
            if (entitySet.isIncludeInServiceDocument()) {
                entityContainer.getEntitySets().add(entitySet);
            }
        }
    }
    return entityContainer;
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Test
public void getEntityContainer_ContainerWithEntitySetsRetrieved() throws ODataException {
    MultyElasticIndexCsdlEdmProvider edmProvider = spy(
            new MultyElasticIndexCsdlEdmProvider(metaDataProvider, indices));
    List<CsdlSchema> schemas = new ArrayList<>();
    CsdlSchema schema1 = mock(CsdlSchema.class);
    CsdlEntityContainer container = mock(CsdlEntityContainer.class);
    List<CsdlEntitySet> entitySets = new ArrayList<>();
    CsdlEntitySet set1 = mock(CsdlEntitySet.class);
    when(set1.isIncludeInServiceDocument()).thenReturn(true);
    entitySets.add(set1);
    entitySets.add(mock(CsdlEntitySet.class));
    when(container.getEntitySets()).thenReturn(entitySets);
    when(schema1.getEntityContainer()).thenReturn(container);
    schemas.add(schema1);
    CsdlSchema schema2 = mock(CsdlSchema.class);
    when(schema2.getEntityContainer()).thenReturn(mock(CsdlEntityContainer.class));
    schemas.add(schema2);
    doReturn(schemas).when(edmProvider).getSchemas();
    CsdlEntityContainer entityContainer = edmProvider.getEntityContainer();
    assertEquals(edmProvider.getContainerName().getName(), entityContainer.getName());
    assertEquals(1, entityContainer.getEntitySets().size());
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Override
public CsdlEntityContainer getEntityContainer() throws ODataException {
  CsdlEntityContainer container = new CsdlEntityContainer();
  List<CsdlEntitySet> entitySets = new ArrayList<CsdlEntitySet>();
  entitySets.add(new CsdlEntitySet().setName("entitySetName"));
  entitySets.add(new CsdlEntitySet().setName("entitySetName2"));
  container.setEntitySets(entitySets);

  List<CsdlSingleton> singletons = new ArrayList<CsdlSingleton>();
  singletons.add(new CsdlSingleton().setName("singletonName"));
  singletons.add(new CsdlSingleton().setName("singletonName2"));
  container.setSingletons(singletons);

  List<CsdlActionImport> actionImports = new ArrayList<CsdlActionImport>();
  actionImports.add(new CsdlActionImport().setName("actionImportName"));
  actionImports.add(new CsdlActionImport().setName("actionImportName2"));
  container.setActionImports(actionImports);

  List<CsdlFunctionImport> functionImports = new ArrayList<CsdlFunctionImport>();
  functionImports.add(new CsdlFunctionImport().setName("functionImportName"));
  functionImports.add(new CsdlFunctionImport().setName("functionImportName2"));
  container.setFunctionImports(functionImports);

  return container;
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Test
public void initialMappingMustBeNull() {
  CsdlProperty property = new CsdlProperty().setType(EdmPrimitiveTypeKind.DateTimeOffset.getFullQualifiedName());
  EdmProperty edmProperty = new EdmPropertyImpl(null, property);
  assertNull(edmProperty.getMapping());

  CsdlParameter parameter = new CsdlParameter().setType(EdmPrimitiveTypeKind.DateTimeOffset.getFullQualifiedName());
  EdmParameter edmParameter = new EdmParameterImpl(null, parameter);
  assertNull(edmParameter.getMapping());

  CsdlEntitySet es = new CsdlEntitySet().setName("test");
  EdmEntitySet edmES = new EdmEntitySetImpl(null, null, es);
  assertNull(edmES.getMapping());

  CsdlSingleton si = new CsdlSingleton().setName("test");
  EdmSingleton edmSi = new EdmSingletonImpl(null, null, si);
  assertNull(edmSi.getMapping());
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
public void getInternalNameViaMapping() {
  CsdlMapping mapping = new CsdlMapping().setInternalName("internalName");

  CsdlProperty property =
      new CsdlProperty().setType(EdmPrimitiveTypeKind.DateTimeOffset.getFullQualifiedName()).setMapping(mapping);
  EdmProperty edmProperty = new EdmPropertyImpl(null, property);
  assertNotNull(edmProperty.getMapping());
  assertEquals("internalName", edmProperty.getMapping().getInternalName());

  CsdlParameter parameter =
      new CsdlParameter().setType(EdmPrimitiveTypeKind.DateTimeOffset.getFullQualifiedName()).setMapping(mapping);
  EdmParameter edmParameter = new EdmParameterImpl(null, parameter);
  assertNotNull(edmParameter.getMapping());
  assertEquals("internalName", edmParameter.getMapping().getInternalName());

  CsdlEntitySet es = new CsdlEntitySet().setName("test").setMapping(mapping);
  EdmEntitySet edmES = new EdmEntitySetImpl(null, null, es);
  assertNotNull(edmES.getMapping());
  assertEquals("internalName", edmES.getMapping().getInternalName());

  CsdlSingleton si = new CsdlSingleton().setName("test").setMapping(mapping);
  EdmSingleton edmSi = new EdmSingletonImpl(null, null, si);
  assertNotNull(edmSi.getMapping());
  assertEquals("internalName", edmSi.getMapping().getInternalName());
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Test
public void uriParserExceptionResultsInRightResponseEdmCause() throws Exception {
  final OData odata = OData.newInstance();
  final ServiceMetadata serviceMetadata = odata.createServiceMetadata(
      new CsdlAbstractEdmProvider() {
        @Override
        public CsdlEntitySet getEntitySet(final FullQualifiedName entityContainer, final String entitySetName)
            throws ODataException {
          throw new ODataException("msg");
        }
      },
      Collections.<EdmxReference> emptyList());

  ODataRequest request = new ODataRequest();
  request.setMethod(HttpMethod.GET);
  request.setRawODataPath("EdmException");

  final ODataResponse response =
      new ODataHandlerImpl(odata, serviceMetadata, new ServerCoreDebugger(odata)).process(request);
  assertNotNull(response);
  assertEquals(HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatusCode());
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
/**
 * This looks for the correct entity set 
 * when the target entity set is part of some other namespace
 * e.g <NavigationPropertyBinding Path="Products" Target="SomeModel.SomeContainer/SomeSet" />
 * @param navBindingTarget
 * @return String
 */
private String findLastQualifiedTargetName(String navBindingTarget) {
  String[] targetPaths = navBindingTarget.split("/");
  CsdlEntityContainer csdlContainer = csdlContainersMap.containsKey(new FullQualifiedName(targetPaths[0])) ?
    csdlContainersMap.get(new FullQualifiedName(targetPaths[0])) : 
      csdlContainersMap.get(fetchCorrectNamespaceFromAlias(new FullQualifiedName(targetPaths[0])));
  if (csdlContainer == null) {
    throw new RuntimeException("Container with FullyQualifiedName " + targetPaths[0] + " not found.");
  }
  String targetEntitySetName = targetPaths[1];
  CsdlEntitySet csdlEntitySet = csdlContainer.getEntitySet(targetEntitySetName);
  if (csdlEntitySet == null) {
    throw new RuntimeException("Target Entity Set mentioned in navigationBindingProperty "
        + "not found in the container " + csdlContainer.getName());
  }
  FullQualifiedName fqName = csdlEntitySet.getTypeFQN();
  if (!(csdlEntityTypesMap.containsKey(fqName))) {
    fqName = validateCsdlEntityTypeWithAlias(fqName);
  }
  return fqName.getFullQualifiedNameAsString();
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Override
public CsdlEntityContainer getEntityContainer() {

  // create EntitySets
  List<CsdlEntitySet> entitySets = new ArrayList<CsdlEntitySet>();
  entitySets.add(getEntitySet(CONTAINER, ES_PRODUCTS_NAME));
  entitySets.add(getEntitySet(CONTAINER, ES_CATEGORIES_NAME));
  entitySets.add(getEntitySet(CONTAINER, ES_ADVERTISEMENTS_NAME));
  
  // Create function imports
  List<CsdlFunctionImport> functionImports = new ArrayList<CsdlFunctionImport>();
  functionImports.add(getFunctionImport(CONTAINER, FUNCTION_COUNT_CATEGORIES));
  
  // Create action imports
  List<CsdlActionImport> actionImports = new ArrayList<CsdlActionImport>();
  actionImports.add(getActionImport(CONTAINER, ACTION_RESET));
  
  // create EntityContainer
  CsdlEntityContainer entityContainer = new CsdlEntityContainer();
  entityContainer.setName(CONTAINER_NAME);
  entityContainer.setActionImports(actionImports);
  entityContainer.setFunctionImports(functionImports);
  entityContainer.setEntitySets(entitySets);

  return entityContainer;
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
public CsdlEntityContainer getEntityContainer() {
  // create EntitySets
  List<CsdlEntitySet> entitySets = new ArrayList<CsdlEntitySet>();
  entitySets.add(getEntitySet(CONTAINER, ES_PRODUCTS_NAME));
  entitySets.add(getEntitySet(CONTAINER, ES_CATEGORIES_NAME));
  
  // Create function imports
  List<CsdlFunctionImport> functionImports = new ArrayList<CsdlFunctionImport>();
  functionImports.add(getFunctionImport(CONTAINER, FUNCTION_COUNT_CATEGORIES));
  
  // Create action imports
  List<CsdlActionImport> actionImports = new ArrayList<CsdlActionImport>();
  actionImports.add(getActionImport(CONTAINER, ACTION_RESET));
  
  // create EntityContainer
  CsdlEntityContainer entityContainer = new CsdlEntityContainer();
  entityContainer.setName(CONTAINER_NAME);
  entityContainer.setEntitySets(entitySets);
  entityContainer.setFunctionImports(functionImports);
  entityContainer.setActionImports(actionImports);
  
  return entityContainer;

}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Override
public CsdlEntitySet getEntitySet(FullQualifiedName entityContainer, String entitySetName) {

  if(entityContainer.equals(CONTAINER)){
    if(entitySetName.equals(ES_PRODUCTS_NAME)){
      CsdlEntitySet entitySet = new CsdlEntitySet();
      entitySet.setName(ES_PRODUCTS_NAME);
      entitySet.setType(ET_PRODUCT_FQN);

      return entitySet;
    }
  }

  return null;

}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Override
public CsdlEntitySet getEntitySet(final FullQualifiedName entityContainer, final String entitySetName)
    throws ODataException {
  if (CONTAINER_FQN.equals(entityContainer)) {
    if (ES_CARS_NAME.equals(entitySetName)) {
      return new CsdlEntitySet()
          .setName(ES_CARS_NAME)
          .setType(ET_CAR)
          .setNavigationPropertyBindings(
              Arrays.asList(
                  new CsdlNavigationPropertyBinding().setPath("Manufacturer").setTarget(
                      CONTAINER_FQN.getFullQualifiedNameAsString() + "/" + ES_MANUFACTURER_NAME)));
    } else if (ES_MANUFACTURER_NAME.equals(entitySetName)) {
      return new CsdlEntitySet()
          .setName(ES_MANUFACTURER_NAME)
          .setType(ET_MANUFACTURER).setNavigationPropertyBindings(
              Arrays.asList(
                  new CsdlNavigationPropertyBinding().setPath("Cars")
                      .setTarget(CONTAINER_FQN.getFullQualifiedNameAsString() + "/" + ES_CARS_NAME)));
    }
  }

  return null;
}
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
public AbstractEdmProvider(List<CsdlProvider> providers) {

        // Set is always in the context of container.
        List<CsdlEntitySet> entitySets = new ArrayList<>();

        providers.forEach(csdlProvider -> {
            CsdlEntitySet set = csdlProvider.getCsdlEntitySet();
            if (set != null) {
                entitySets.add(set);
            }

            updateTypesMapWithType(csdlProvider.getCsdlEntityType(), entities);

            updateTypesMapWithType(csdlProvider.getCsdlEnumType(), enums);
            updateTypesMapWithType(csdlProvider.getCsdlComplexType(), complexTypes);

            updateOperationsMapFromList(csdlProvider.getCsdlActions(), actions);
            updateOperationsMapFromList(csdlProvider.getCsdlFunctions(), functions);
        });

        container.setEntitySets(entitySets).setActionImports(getActionImports())
                 .setFunctionImports(getFunctionImports());

        schemas.add(
                new CsdlSchema().setNamespace(FullQualifiedNamesUtil.NAMESPACE.ENTITIES).setEntityContainer(container)
                                .setEntityTypes(new ArrayList<>(entities.values())));
        schemas.add(new CsdlSchema().setNamespace(FullQualifiedNamesUtil.NAMESPACE.ACTIONS)
                                    .setActions(normalizeOperations(actions)));
        schemas.add(new CsdlSchema().setNamespace(FullQualifiedNamesUtil.NAMESPACE.FUNCTIONS)
                                    .setFunctions(normalizeOperations(functions)));
        schemas.add(new CsdlSchema().setNamespace(FullQualifiedNamesUtil.NAMESPACE.ENUMS)
                                    .setEnumTypes(new ArrayList<>(enums.values())));
        schemas.add(new CsdlSchema().setNamespace(FullQualifiedNamesUtil.NAMESPACE.COMPLEX_TYPES)
                                    .setComplexTypes(new ArrayList<>(complexTypes.values())));
    }
 

import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; //导入依赖的package包/类
@Override
public CsdlEntitySet getEntitySet(FullQualifiedName entityContainer, String entitySetName) {
    if (entityContainer.equals(FullQualifiedNamesUtil.CONTAINER_FQN)) {
        return container.getEntitySet(entitySetName);
    }
    return null;
}