parse-sap-odata 1.4.9

Generate a pair of Rust modules from SAP V2 OData metadata
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# OData Complex Types

In the event an Entity Type definition uses a complex type, then the complex type is first created as a Rust `struct`.

The naming convention for a complex type is the Schema namespace followed by a dot `.` then the complex type name to which the prefix `CT_` has been added.

E.G. In the `BusinessPartner` entity type, the `Address` property is the complex type `GWSAMPLE_BASIC.CT_Address`.

```xml
<EntityType Name="BusinessPartner" sap:content-version="1">
  <Key>
    <PropertyRef Name="BusinessPartnerID"/>
  </Key>
  <Property Name="Address" Type="GWSAMPLE_BASIC.CT_Address" Nullable="false"/>

  <!-- SNIP -->

</EntityType>
```

This refers to the `<ComplexType>` definition:

```xml
<ComplexType Name="CT_Address">
  <Property Name="City"        Type="Edm.String" MaxLength="40" sap:label="City"        sap:semantics="city"/>
  <Property Name="PostalCode"  Type="Edm.String" MaxLength="10" sap:label="Postal Code" sap:semantics="zip"/>
  <Property Name="Street"      Type="Edm.String" MaxLength="60" sap:label="Street"      sap:semantics="street"/>
  <Property Name="Country"     Type="Edm.String" MaxLength="3"  sap:label="Country"     sap:semantics="country"/>
  <Property Name="Building"    Type="Edm.String" MaxLength="10" sap:label="Building"/>
  <Property Name="AddressType" Type="Edm.String" MaxLength="2"  sap:label="Address Type"/>
</ComplexType>
```

So the above XML complex type definition is transformed into the following Rust `struct`:

```rust
#[derive(Clone, Debug, Default)]
pub struct CtAddress {
    pub address_type: Option<String>,
    pub building: Option<String>,
    pub city: Option<String>,
    pub country: Option<String>,
    pub postal_code: Option<String>,
    pub street: Option<String>,
}
```

Then the `<EntityType>` for `BusinessPartner` is translated into the following Rust `struct`

```rust
pub struct BusinessPartner {
    pub address: CtAddress,
    pub business_partner_id: String,
    //SNIP
}
```

---

## OData "Simple" Complex Types

The metadata for the `GWSAMPLE_BASIC` OData service also contains the following complex type:

```xml
<ComplexType Name="CT_String">
  <Property Name="String" Type="Edm.String" Nullable="false" sap:creatable="false" sap:updatable="false" sap:sortable="false" sap:filterable="false"/>
</ComplexType>
```

This particular type turns out not to be complex at all because it contains a single field of type `Edm.String`.
Since this is directly equivalent to a standard Rust `String`, it would be redundant to wrap a single Rust `String` inside a `struct`.

Therefore, these "simple" complex types are ignored, and the corresponding `<EntityType>` field is declared simply as the equivalent Rust type.