private DataProperty ParseCsdlComplexProperty(StructuralType parentType, JObject csdlProperty) { // Complex properties are never nullable ( per EF specs) // var isNullable = csdlProperty.nullable === 'true' || csdlProperty.nullable == null; var complexTypeName = GetClientTypeNameFromClrTypeName((String)csdlProperty["type"]); // can't set the name until we go thru namingConventions and these need the dp. var nameOnServer = (String)csdlProperty["name"]; var name = NamingConvention.ServerPropertyNameToClient(nameOnServer, parentType); var dp = parentType.GetDataProperty(name); if (dp == null) { MetadataStore.OnMetadataMismatch(parentType.Name, name, MetadataMismatchTypes.MissingCLRDataProperty); return(null); } if (!dp.IsComplexProperty) { var detail = "Defined as a ComplexProperty on the server but not on the client"; MetadataStore.OnMetadataMismatch(parentType.Name, name, MetadataMismatchTypes.InconsistentCLRPropertyDefinition, detail); return(null); } CheckProperty(dp, dp.ComplexType.Name, complexTypeName, "ComplexTypeName"); return(dp); }
private DataProperty ParseCsdlDataProperty(StructuralType parentType, JObject csdlProperty, List <String> keyNamesOnServer) { DataProperty dp; var typeParts = ExtractTypeNameParts(csdlProperty); if (typeParts.Length == 2) { dp = ParseCsdlSimpleProperty(parentType, csdlProperty, keyNamesOnServer); } else { if (IsEnumType(csdlProperty)) { dp = ParseCsdlSimpleProperty(parentType, csdlProperty, keyNamesOnServer); dp.EnumTypeName = (String)csdlProperty["type"]; } else { dp = ParseCsdlComplexProperty(parentType, csdlProperty); } } if (dp != null) { AddValidators(dp); } return(dp); }
internal void CheckStructuralType(StructuralType stType, Object v1, Object v2, String name) { if (v1 == null && v2 == null) { return; } if (Object.Equals(v1, v2)) { return; } var detail = String.Format("Type property: {0}, Client value: '{1}', Server value: '{2}'", name, (v1 ?? "").ToString(), (v2 ?? "").ToString()); MetadataStore.OnMetadataMismatch(stType.Name, null, MetadataMismatchType.InconsistentCLRTypeDefinition, detail); }
private static void UpdateBaseProperties(StructuralType structuralType, StructuralType baseStructuralType) { baseStructuralType.DataProperties.ForEach(dp => { var newDp = new DataProperty(dp); structuralType.AddDataProperty(newDp); }); if (baseStructuralType.IsEntityType) { var entityType = (EntityType)structuralType; var baseEntityType = (EntityType)baseStructuralType; baseEntityType.NavigationProperties.ForEach(np => { var newNp = new NavigationProperty(np); entityType.AddNavigationProperty(newNp); }); } }
private void AddStructuralType(StructuralType stType, bool allowMerge = true) { // don't register anon types if (stType.IsAnonymous) { return; } lock (_structuralTypes) { if (_structuralTypes.ContainsKey(stType.Name)) { throw new Exception("Type " + stType.Name + " already exists in this MetadataStore."); } _structuralTypes.Add(stType); _shortNameMap[stType.ShortName] = stType.Name; } }
public Type GetClrType(StructuralType stType) { TypePair tp; if (_map.TryGetValue(stType.Name, out tp)) { stType.ClrType = tp.ClrType; if (tp.StructuralType == null) { tp.StructuralType = stType; } return(tp.ClrType); } else { _map.Add(stType.Name, new TypePair() { StructuralType = stType }); return(null); } }
private static DataProperty CreateDataProperty(StructuralType structuralType, PropertyInfo pInfo) { var propType = pInfo.PropertyType; var dp = new DataProperty(pInfo.Name); // TODO: handle isScalar if (typeof(IComplexObject).IsAssignableFrom(propType)) { dp.ComplexType = GetComplexType(propType); dp.IsNullable = false; // complex Objects do not have defaultValues currently } else { dp.ClrType = propType; dp.DataType = DataType.FromClrType(TypeFns.GetNonNullableType(propType)); dp.IsNullable = TypeFns.IsNullableType(propType); dp.DefaultValue = dp.IsNullable ? null : dp.DataType.DefaultValue; } structuralType.AddDataProperty(dp); return(dp); }
public String TestPropertyName(String testVal, StructuralType parentType, bool toServer) { Func <String, StructuralType, String> fn1; Func <String, StructuralType, String> fn2; if (toServer) { fn1 = ClientPropertyNameToServer; fn2 = ServerPropertyNameToClient; } else { fn1 = ServerPropertyNameToClient; fn2 = ClientPropertyNameToServer; } var t1 = fn1(testVal, parentType); var t2 = fn2(t1, parentType); if (t2 != testVal) { throw new Exception("NamingConvention: " + this.Name + " does not roundtrip the following value correctly: " + testVal); } return(t1); }
private DataProperty ParseCsdlSimpleProperty(StructuralType parentType, JObject csdlProperty, List <String> keyNamesOnServer) { var typeVal = (String)csdlProperty["type"]; var nameVal = (String)csdlProperty["name"]; var nullableVal = (String)csdlProperty["nullable"]; var maxLengthVal = (String)csdlProperty["maxLength"]; var concurrencyModeVal = (String)csdlProperty["concurrencyMode"]; var dataType = DataType.FromEdmType(typeVal); if (dataType == DataType.Undefined) { parentType.Warnings.Add("Unable to recognize DataType for property: " + nameVal + " DateType: " + typeVal); } var dpName = NamingConvention.ServerPropertyNameToClient(nameVal, parentType); var dp = parentType.GetDataProperty(dpName); if (dp == null) { MetadataStore.OnMetadataMismatch(parentType.Name, dpName, MetadataMismatchType.MissingCLRDataProperty); return(null); } var isNullable = nullableVal == "true" || nullableVal == null; var entityType = parentType as EntityType; bool isPartOfKey = false; bool isAutoIncrementing = false; if (entityType != null) { isPartOfKey = keyNamesOnServer != null && keyNamesOnServer.IndexOf(nameVal) >= 0; if (isPartOfKey && entityType.AutoGeneratedKeyType == AutoGeneratedKeyType.None) { if (IsIdentityProperty(csdlProperty)) { isAutoIncrementing = true; entityType.AutoGeneratedKeyType = AutoGeneratedKeyType.Identity; } } } Object defaultValue; var rawDefaultValue = csdlProperty["defaultValue"]; if (rawDefaultValue == null) { defaultValue = isNullable ? null : dataType.DefaultValue; } else { defaultValue = rawDefaultValue.ToObject(dataType.ClrType); } // TODO: nit - don't set maxLength if null; var maxLength = (maxLengthVal == null || maxLengthVal == "Max") ? (Int64?)null : Int64.Parse(maxLengthVal); var concurrencyMode = concurrencyModeVal == "fixed" ? ConcurrencyMode.Fixed : ConcurrencyMode.None; CheckProperty(dp, dp.DataType, dataType, "DataType"); CheckProperty(dp, dp.IsScalar, true, "IsScalar"); dp.IsPartOfKey = isPartOfKey; dp.IsNullable = isNullable; dp.MaxLength = maxLength; dp.DefaultValue = defaultValue; // fixedLength: fixedLength, dp.ConcurrencyMode = concurrencyMode; dp.IsAutoIncrementing = isAutoIncrementing; if (dataType == DataType.Undefined) { dp.RawTypeName = typeVal; } return(dp); }
/// <summary> /// Translates a server property name into a client property name. /// </summary> /// <param name="clientName"></param> /// <param name="parentType"></param> /// <returns></returns> public virtual String ServerPropertyNameToClient(String clientName, StructuralType parentType) { return(clientName); }
public override String ClientPropertyNameToServer(String clientName, StructuralType parentType) { return(clientName.Substring(0, 1).ToUpper() + clientName.Substring(1)); }
public override String ServerPropertyNameToClient(String serverName, StructuralType parentType) { return(serverName.Substring(0, 1).ToLower() + serverName.Substring(1)); }
/// <summary> /// Translates a server property name into a client property name. /// </summary> /// <param name="serverName"></param> /// <param name="parentType"></param> /// <returns></returns> public virtual String ClientPropertyNameToServer(String serverName, StructuralType parentType) { return(serverName); }
internal Type GetClrTypeFor(StructuralType stType) { lock (_structuralTypes) { return(_clrTypeMap.GetClrType(stType)); } }