Add support for EntitySet in OData V4

Author: mamiksik

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Separate type repositories for individual versions of OData - Martin Miksik
 - Support for OData V4 primitive types - Martin Miksik
 - Support for navigation property in OData v4 - Martin Miksik
+- Support for EntitySet in OData v4 - Martin Miksik
 
 ### Changed
 - Implementation and naming schema of `from_etree` - Martin Miksik

pyodata/model/build_functions.py

@@ -10,6 +10,9 @@
     Types, EntitySet, ValueHelper, ValueHelperParameter, FunctionImportParameter, \
     FunctionImport, metadata_attribute_get, EntityType, ComplexType, Annotation, build_element
 
+from pyodata.v4 import ODataV4
+import pyodata.v4.elements as v4
+
 
 def modlog():
     return logging.getLogger("callbacks")
@@ -103,6 +106,10 @@ def build_entity_set(config, entity_set_node):
     name = entity_set_node.get('Name')
     et_info = Types.parse_type_name(entity_set_node.get('EntityType'))
 
+    nav_prop_bins = []
+    for nav_prop_bin in entity_set_node.xpath('edm:NavigationPropertyBinding', namespaces=config.namespaces):
+        nav_prop_bins.append(build_element('NavigationPropertyBinding', config, node=nav_prop_bin, et_info=et_info))
+
     # TODO: create a class SAP attributes
     addressable = sap_attribute_get_bool(entity_set_node, 'addressable', True)
     creatable = sap_attribute_get_bool(entity_set_node, 'creatable', True)
@@ -115,6 +122,10 @@ def build_entity_set(config, entity_set_node):
     req_filter = sap_attribute_get_bool(entity_set_node, 'requires-filter', False)
     label = sap_attribute_get_string(entity_set_node, 'label')
 
+    if config.odata_version == ODataV4:
+        return v4.EntitySet(name, et_info, addressable, creatable, updatable, deletable, searchable, countable, pageable,
+                         topable, req_filter, label, nav_prop_bins)
+
     return EntitySet(name, et_info, addressable, creatable, updatable, deletable, searchable, countable, pageable,
                      topable, req_filter, label)
 

pyodata/model/elements.py

@@ -590,7 +590,10 @@ def nav_proprties(self):
         return list(self._nav_properties.values())
 
     def nav_proprty(self, property_name):
-        return self._nav_properties[property_name]
+        try:
+            return self._nav_properties[property_name]
+        except KeyError as ex:
+            raise PyODataModelError(f'{self} does not contain navigation property {property_name}') from ex
 
 
 class EntitySet(Identifier):

pyodata/policies.py

@@ -12,11 +12,13 @@ class ParserError(Enum):
     """ Represents all the different errors the parser is able to deal with."""
     PROPERTY = auto()
     NAVIGATION_PROPERTY = auto()
+    NAVIGATION_PROPERTY_BIDING = auto()
     ANNOTATION = auto()
     ASSOCIATION = auto()
 
     ENUM_TYPE = auto()
     ENTITY_TYPE = auto()
+    ENTITY_SET = auto()
     COMPLEX_TYPE = auto()
     REFERENTIAL_CONSTRAINT = auto()
 

pyodata/v4/__init__.py

@@ -6,7 +6,7 @@
 from pyodata.model.type_traits import EdmBooleanTypTraits, EdmIntTypTraits
 from pyodata.model.elements import Typ, Schema, ComplexType, StructType, StructTypeProperty, EntityType
 
-from pyodata.v4.elements import NavigationTypeProperty, EnumType
+from pyodata.v4.elements import NavigationTypeProperty, NavigationPropertyBinding, EntitySet, EnumType
 from pyodata.v4.type_traits import EdmDateTypTraits, GeoTypeTraits, EdmDoubleQuotesEncapsulatedTypTraits, \
     EdmTimeOfDay, EdmDateTimeOffsetTypTraits, EdmDuration
 
@@ -23,9 +23,11 @@ def build_functions():
             StructTypeProperty: build_functions.build_struct_type_property,
             StructType: build_functions.build_struct_type,
             NavigationTypeProperty: build_functions_v4.build_navigation_type_property,
+            NavigationPropertyBinding: build_functions_v4.build_navigation_property_binding,
             EnumType: build_functions_v4.build_enum_type,
             ComplexType: build_functions.build_complex_type,
             EntityType: build_functions.build_entity_type,
+            EntitySet: build_functions.build_entity_set,
             Schema: build_functions_v4.build_schema,
         }
 

pyodata/v4/build_functions.py

@@ -7,7 +7,8 @@
 from pyodata.exceptions import PyODataParserError, PyODataModelError
 from pyodata.model.elements import ComplexType, Schema, NullType, build_element, EntityType, Types, StructTypeProperty
 from pyodata.policies import ParserError
-from pyodata.v4.elements import NavigationTypeProperty, NullProperty, ReferentialConstraint, EnumMember, EnumType
+from pyodata.v4.elements import NavigationTypeProperty, NullProperty, ReferentialConstraint,\
+    NavigationPropertyBinding, to_path_info, EntitySet, EnumMember, EnumType
 
 
 # pylint: disable=protected-access,too-many-locals,too-many-branches,too-many-statements
@@ -110,10 +111,33 @@ def build_schema(config: Config, schema_nodes):
                 ref_con.proprty = proprty
                 ref_con.referenced_proprty = referenced_proprty
 
-    # TODO: Then, process Associations nodes because they refer EntityTypes and they are referenced by AssociationSets.
-    # TODO: Then, process EntitySet, FunctionImport and AssociationSet nodes.
-    # TODO: Finally, process Annotation nodes when all Scheme nodes are completely processed.
+    # Process entity sets
+    for schema_node in schema_nodes:
+        namespace = schema_node.get('Namespace')
+        decl = schema._decls[namespace]
 
+        for entity_set in schema_node.xpath('edm:EntityContainer/edm:EntitySet', namespaces=config.namespaces):
+            try:
+                eset = build_element(EntitySet, config, entity_set_node=entity_set)
+                eset.entity_type = schema.entity_type(eset.entity_type_info[1], namespace=eset.entity_type_info[0])
+                decl.entity_sets[eset.name] = eset
+            except (PyODataParserError, KeyError) as ex:
+                config.err_policy(ParserError.ENTITY_SET).resolve(ex)
+
+    # After all entity sets are parsed resolve the individual bindings among them and entity types
+    for entity_set in schema.entity_sets:
+        for nav_prop_bin in entity_set.navigation_property_bindings:
+            path_info = nav_prop_bin.path_info
+            try:
+                nav_prop_bin.path = schema.entity_type(path_info.type,
+                                                       namespace=path_info.namespace).nav_proprty(path_info.proprty)
+                nav_prop_bin.target = schema.entity_set(nav_prop_bin.target_info)
+            except (PyODataModelError, KeyError) as ex:
+                config.err_policy(ParserError.NAVIGATION_PROPERTY_BIDING).resolve(ex)
+                nav_prop_bin.path = NullType(path_info.type)
+                nav_prop_bin.target = NullProperty(nav_prop_bin.target_info)
+
+    # TODO: Finally, process Annotation nodes when all Scheme nodes are completely processed.
     return schema
 
 
@@ -133,6 +157,10 @@ def build_navigation_type_property(config: Config, node):
         ref_cons)
 
 
+def build_navigation_property_binding(config: Config, node, et_info):
+    return NavigationPropertyBinding(to_path_info(node.get('Path'), et_info), node.get('Target'))
+
+
 # pylint: disable=protected-access, too-many-locals
 def build_enum_type(config: Config, type_node, namespace):
     ename = type_node.get('Name')

pyodata/v4/elements.py

@@ -1,11 +1,26 @@
 """ Repository of elements specific to the ODATA V4"""
 from typing import Optional, List
 
+import collections
+
+from pyodata.model import elements
 from pyodata.exceptions import PyODataModelError, PyODataException
-from pyodata.model.elements import VariableDeclaration, StructType, Identifier
+from pyodata.model.elements import VariableDeclaration, StructType, TypeInfo, Identifier
 from pyodata.model.type_traits import TypTraits
 from pyodata.v4.type_traits import EnumTypTrait
 
+PathInfo = collections.namedtuple('PathInfo', 'namespace type proprty')
+
+
+def to_path_info(value: str, et_info: TypeInfo):
+    """ Helper function for parsing Path attribute on NavigationPropertyBinding property """
+    if '/' in value:
+        parts = value.split('.')
+        entity_name, property_name = parts[-1].split('/')
+        return PathInfo('.'.join(parts[:-1]), entity_name, property_name)
+    else:
+        return PathInfo(et_info.namespace, et_info.name, value)
+
 
 class NullProperty:
     """ Defines fallback class when parser is unable to process property defined in xml """
@@ -94,6 +109,64 @@ def referential_constraints(self) -> List[ReferentialConstraint]:
         return self._referential_constraints
 
 
+class NavigationPropertyBinding:
+    """ Describes which entity set of navigation property contains related entities
+        https://docs.oasis-open.org/odata/odata-csdl-xml/v4.01/csprd06/odata-csdl-xml-v4.01-csprd06.html#sec_NavigationPropertyBinding
+    """
+
+    def __init__(self, path_info: PathInfo, target_info: str):
+        self._path_info = path_info
+        self._target_info = target_info
+        self._path: Optional[NavigationTypeProperty] = None
+        self._target: Optional['EntitySet'] = None
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.path}, {self.target})"
+
+    def __str__(self):
+        return f"{self.__class__.__name__}({self.path}, {self.target})"
+
+    @property
+    def path_info(self) -> PathInfo:
+        return self._path_info
+
+    @property
+    def target_info(self):
+        return self._target_info
+
+    @property
+    def path(self) -> Optional[NavigationTypeProperty]:
+        return self._path
+
+    @path.setter
+    def path(self, value: NavigationTypeProperty):
+        self._path = value
+
+    @property
+    def target(self) -> Optional['EntitySet']:
+        return self._target
+
+    @target.setter
+    def target(self, value: 'EntitySet'):
+        self._target = value
+
+
+class EntitySet(elements.EntitySet):
+    """ EntitySet complaint with OData V4
+        https://docs.oasis-open.org/odata/odata-csdl-xml/v4.01/csprd06/odata-csdl-xml-v4.01-csprd06.html#sec_EntitySet
+    """
+    def __init__(self, name, entity_type_info, addressable, creatable, updatable, deletable, searchable, countable,
+                 pageable, topable, req_filter, label, navigation_property_bindings):
+        super(EntitySet, self).__init__(name, entity_type_info, addressable, creatable, updatable, deletable,
+                                        searchable, countable, pageable, topable, req_filter, label)
+
+        self._navigation_property_bindings = navigation_property_bindings
+
+    @property
+    def navigation_property_bindings(self) -> List[NavigationPropertyBinding]:
+        return self._navigation_property_bindings
+
+
 class EnumMember:
     """ Represents individual enum values """
     def __init__(self, parent, name, value):

tests/test_model_v4.py

@@ -3,12 +3,14 @@
 import geojson
 import pytest
 
-from pyodata.policies import PolicyIgnore
+from pyodata.policies import PolicyIgnore, ParserError
 from pyodata.model.builder import MetadataBuilder
 from pyodata.exceptions import PyODataModelError, PyODataException, PyODataParserError
-from pyodata.model.elements import Types, TypeInfo, NullType
+from pyodata.model.elements import Types, TypeInfo, Schema, NullType
 
 from pyodata.config import Config
+from tests.conftest import metadata
+from pyodata.v4.elements import NavigationTypeProperty, EntitySet, NavigationPropertyBinding
 from pyodata.v4 import ODataV4, NavigationTypeProperty
 
 
@@ -171,6 +173,69 @@ def test_referential_constraint(schema_v4):
         'ReferentialConstraint(StructTypeProperty(CategoryID), StructTypeProperty(ID))'
 
 
+def test_navigation_property_binding(schema_v4: Schema):
+    """Test parsing of navigation property bindings on EntitySets"""
+    eset: EntitySet = schema_v4.entity_set('People')
+    assert str(eset) == 'EntitySet(People)'
+
+    nav_prop_biding: NavigationPropertyBinding = eset.navigation_property_bindings[0]
+    assert repr(nav_prop_biding) == "NavigationPropertyBinding(NavigationTypeProperty(Friends), EntitySet(People))"
+
+
+def test_invalid_property_binding_on_entity_set(xml_builder_factory):
+    """Test parsing of invalid property bindings on EntitySets"""
+    schema = """
+    <EntityType Name="Person">
+            <NavigationProperty Name="Friends" Type="Collection(MightySchema.Person)" Partner="Friends" />
+        </EntityType>
+        <EntityContainer Name="DefaultContainer">
+            <EntitySet Name="People" EntityType="{}">
+                    <NavigationPropertyBinding Path="{}" Target="{}" />
+            </EntitySet>
+        </EntityContainer>
+    """
+
+    etype, path, target = 'MightySchema.Person', 'Friends', 'People'
+
+    xml_builder = xml_builder_factory()
+    xml_builder.add_schema('MightySchema', schema.format(etype, 'Mistake', target))
+    xml = xml_builder.serialize()
+
+    with pytest.raises(PyODataModelError) as ex_info:
+        MetadataBuilder(xml, Config(ODataV4)).build()
+    assert ex_info.value.args[0] == 'EntityType(Person) does not contain navigation property Mistake'
+
+    try:
+        MetadataBuilder(xml, Config(ODataV4, custom_error_policies={
+            ParserError.NAVIGATION_PROPERTY_BIDING: PolicyIgnore()
+        })).build()
+    except BaseException as ex:
+        raise pytest.fail(f'IgnorePolicy was supposed to silence "{ex}" but it did not.')
+
+    xml_builder = xml_builder_factory()
+    xml_builder.add_schema('MightySchema', schema.format('Mistake', path, target))
+    xml = xml_builder.serialize()
+
+    with pytest.raises(KeyError) as ex_info:
+        MetadataBuilder(xml, Config(ODataV4)).build()
+    assert ex_info.value.args[0] == 'EntityType Mistake does not exist in any Schema Namespace'
+
+    try:
+        MetadataBuilder(xml, Config(ODataV4, custom_error_policies={
+            ParserError.ENTITY_SET: PolicyIgnore()
+        })).build()
+    except BaseException as ex:
+        raise pytest.fail(f'IgnorePolicy was supposed to silence "{ex}" but it did not.')
+
+    xml_builder = xml_builder_factory()
+    xml_builder.add_schema('MightySchema', schema.format(etype, path, 'Mistake'))
+    xml = xml_builder.serialize()
+
+    with pytest.raises(KeyError) as ex_info:
+        MetadataBuilder(xml, Config(ODataV4)).build()
+    assert ex_info.value.args[0] == 'EntitySet Mistake does not exist in any Schema Namespace'
+
+
 def test_enum_parsing(schema_v4):
     """Test correct parsing of enum"""