Add odata type to complex types for .Net and PHP (#154)

* Added code to generate compexTypes with odataType property
* Add the @odata.type property to all base classes and set the ODataType on all non-abstract complex types.
* Only create a constructor that initializes the ODataType when the complexType's base class is abstract, and that abstract base class is referenced as the type of a property in the OdcmModel. We need this change so that we can automatically set the ODataType when the service can't infer the type by the payloads content.
* Updated PHP template to support setting ODataType when initializing an object that is descended from an abstract base.

Author: MIchaelMainer

Templates/CSharp/Model/ComplexType.cs.tt

@@ -42,7 +42,17 @@ namespace <#=complex.Namespace.GetNamespaceName()#>
     <#=attributeStringBuilder.ToString()#>
     public <#=classType#> <#=typeDeclaration#>
     {
-    <#
+<#
+// Generate a constructor to initialize the @odata.type property when this type is not abstract and if this 
+// type's base is abstract and the base is referenced as the type of a structural property. We need this
+// to disambiguate the type of the descendant class being sent. 
+if (complex.IsBaseAbstractAndReferencedAsPropertyType() && !complex.IsAbstract)
+{
+#>        public <#=complexTypeName#>()
+        {
+            this.ODataType = "<#=complex.FullName#>";
+        }<#
+}
         foreach(var property in complex.Properties)
         {
 
@@ -86,6 +96,7 @@ namespace <#=complex.Namespace.GetNamespaceName()#>
         }
 
     // Only include AdditionalData in the base classes.
+    // Adding odata.type to all complex types with no base class. 
     if (complex.Base == null)
     {
     #>
@@ -95,6 +106,12 @@ namespace <#=complex.Namespace.GetNamespaceName()#>
         /// </summary>
         [JsonExtensionData(ReadData = true)]
         public IDictionary<string, object> AdditionalData { get; set; }
+
+        /// <summary>
+        /// Gets or sets @odata.type.
+        /// </summary>
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore, PropertyName = "@odata.type", Required = Newtonsoft.Json.Required.Default)]
+        public string ODataType { get; set; }
     <#
     }
     #>

Templates/PHP/Model/ComplexType.php.tt

@@ -27,6 +27,22 @@ class <#=complexName.ToCheckedCase()#> extends Entity
 #>
 {
 <# 
+// Generate a constructor to initialize the @odata.type property when this type is not abstract and if this 
+// type's base is abstract and the base is referenced as the type of a structural property. We need this
+// to disambiguate the type of the descendant class being sent. 
+if (complex.IsBaseAbstractAndReferencedAsPropertyType() && !complex.IsAbstract)
+{
+#>    /**
+    * Set the @odata.type since this type is immediately descended from an abstract
+    * type that is referenced as the type in an entity.
+    */
+    public function __construct()
+    {
+        $this->setODataType("#<#=complex.FullName#>");
+    }
+
+<# 
+}
 foreach(var property in complex.Properties.Where(prop => prop.Type.GetTypeString() != "bytes")){
     var propertyName = property.Name.SanitizePropertyName(complexName);
     if (!property.Type.IsComplex()) {

src/GraphODataTemplateWriter/Extensions/OdcmModelExtensions.cs

@@ -223,6 +223,30 @@ public static string GetImplicitPropertyName(this OdcmProperty property, OdcmSin
             return implicitPropertyName;
         }
 
+        /// <summary>
+        /// Indicates whether the abstract base class of a descendant is referenced as the type of a structural property.
+        /// This has significance to scenarios where client needs to set the @odata.type property because the type cannot
+        /// be inferred since the reference is the to abstract base class and the actual class used by the client is
+        /// one of its descendants. 
+        /// </summary>
+        /// <param name="complex">The ComplexType that we want to query whether its base type is the referenced type for any property in any entity.</param>
+        /// <returns></returns>
+        public static bool IsBaseAbstractAndReferencedAsPropertyType(this OdcmClass complex)
+        {
+            if (complex.Base == null)
+            {
+                return false;
+            }
+            else
+            {
+                return complex.Namespace.Types.Select(someType => (someType as OdcmEntityClass))
+                               .Where(someType => someType is OdcmEntityClass)
+                               .Where(someType => (someType as OdcmEntityClass).Properties
+                                    .Any(x => x.Type.Name == complex.Base.Name && complex.Base.IsAbstract))
+                               .Any();
+            }
+        }
+
         public static IEnumerable<OdcmProperty> NavigationProperties(this OdcmClass odcmClass)
         {
             return odcmClass.Properties.Where(prop => prop.IsNavigation());