private List <PropertyTemplate> GetClassProperties(IEdmSchemaType ent)
{
//stop here for enum
var enumType = ent as IEdmEnumType;
if (enumType != null)
{
return(null);
}
var structuredType = ent as IEdmStructuredType;
var properties = structuredType.Properties();
if (_setting.UseInheritance)
{
properties = properties.Where(x => ((IEdmSchemaType)x.DeclaringType).FullName() == ent.FullName());
}
var list = properties.Select(property => new PropertyTemplate
{
//ToTrace = property.ToTraceString(),
IsNullable = property.Type.IsNullable,
PropName = property.Name,
PropType = GetClrTypeName(property.Type),
//ToDebugString = Helper.Dump(property)
}).ToList();
return(list);
}
public IEdmSchemaType FindDeclaredType(string qualifiedName)
{
IEdmSchemaType edmSchemaType = null;
this.schemaTypeDictionary.TryGetValue(qualifiedName, out edmSchemaType);
return(edmSchemaType);
}
/// <summary>
/// Remove the Edm. prefix from the type name if it is primitive type.
/// </summary>
/// <param name="typeName">The type name to remove the Edm. prefix</param>
/// <returns>The type name without the Edm. Prefix</returns>
internal static string RemoveEdmPrefixFromTypeName(string typeName)
{
if (!string.IsNullOrEmpty(typeName))
{
string itemTypeName = EdmLibraryExtensions.GetCollectionItemTypeName(typeName);
if (itemTypeName == null)
{
IEdmSchemaType primitiveType = EdmLibraryExtensions.ResolvePrimitiveTypeName(typeName);
if (primitiveType != null)
{
return(primitiveType.ShortQualifiedName());
}
}
else
{
IEdmSchemaType primitiveType = EdmLibraryExtensions.ResolvePrimitiveTypeName(itemTypeName);
if (primitiveType != null)
{
return(EdmLibraryExtensions.GetCollectionTypeName(primitiveType.ShortQualifiedName()));
}
}
}
return(typeName);
}
public static Type GetClrType(IEdmType edmType, IEdmModel edmModel, IAssembliesResolver assembliesResolver)
{
IEdmSchemaType edmSchemaType = edmType as IEdmSchemaType;
Contract.Assert(edmSchemaType != null);
ClrTypeAnnotation annotation = edmModel.GetAnnotationValue <ClrTypeAnnotation>(edmSchemaType);
if (annotation != null)
{
return(annotation.ClrType);
}
string typeName = edmSchemaType.FullName();
IEnumerable <Type> matchingTypes = GetMatchingTypes(typeName, assembliesResolver);
if (matchingTypes.Count() > 1)
{
throw Error.Argument("edmTypeReference", SRResources.MultipleMatchingClrTypesForEdmType,
typeName, String.Join(",", matchingTypes.Select(type => type.AssemblyQualifiedName)));
}
edmModel.SetAnnotationValue <ClrTypeAnnotation>(edmSchemaType, new ClrTypeAnnotation(matchingTypes.SingleOrDefault()));
return(matchingTypes.SingleOrDefault());
}
private static object ConvertCollectionValue(ODataCollectionValue collection,
ref IEdmTypeReference propertyType, IODataDeserializerProvider deserializerProvider,
ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType;
if (propertyType == null)
{
// dynamic collection property
Contract.Assert(!String.IsNullOrEmpty(collection.TypeName),
"ODataLib should have verified that dynamic collection value has a type name " +
"since we provided metadata.");
string elementTypeName = GetCollectionElementTypeName(collection.TypeName, isNested: false);
IEdmModel model = readContext.Model;
IEdmSchemaType elementType = model.FindType(elementTypeName);
Contract.Assert(elementType != null);
collectionType =
new EdmCollectionTypeReference(
new EdmCollectionType(elementType.ToEdmTypeReference(isNullable: false)));
propertyType = collectionType;
}
else
{
collectionType = propertyType as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null, "The type for collection must be a IEdmCollectionType.");
}
IODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(collectionType);
return(deserializer.ReadInline(collection, collectionType, readContext));
}
public static Object GetValue(IEdmModel edmModel, ODataEnumValue odataValue)
{
IEdmSchemaType schemaType = edmModel.FindType(odataValue.TypeName);
Type clrType = edmModel.GetClrType((IEdmEnumType)schemaType.AsElementType());
return(Enum.Parse(clrType, odataValue.Value));
}
private static IEdmModel GetEdmModel(HttpConfiguration configuration)
{
var builder = new ODataConventionModelBuilder(configuration);
EntitySetConfiguration <SelectCustomer> customers = builder.EntitySet <SelectCustomer>("SelectCustomer");
customers.EntityType.Action("CreditRating").Returns <double>();
customers.EntityType.Collection.Action("PremiumCustomers").ReturnsCollectionFromEntitySet <SelectCustomer>("SelectCustomer");
builder.EntitySet <EFSelectCustomer>("EFSelectCustomers");
builder.EntitySet <EFSelectOrder>("EFSelectOrders");
builder.EntitySet <SelectOrderDetail>("SelectOrderDetail");
builder.EntityType <SelectPremiumCustomer>();
builder.EntitySet <SelectOrder>("SelectOrder");
builder.EntitySet <SelectBonus>("SelectBonus");
builder.EntitySet <EFWideCustomer>("EFWideCustomers");
builder.Action("ResetDataSource");
builder.Action("ResetDataSource-Order");
IEdmModel model = builder.GetEdmModel();
for (int idx = 1; idx <= 5; idx++)
{
IEdmSchemaType nestedType = model.FindDeclaredType("WebStack.QA.Test.OData.QueryComposition.CustomProperties" + idx);
model.SetAnnotationValue(nestedType, new System.Web.OData.Query.ModelBoundQuerySettings()
{
DefaultSelectType = SelectExpandType.Automatic
});
}
return(model);
}
/// <summary>
/// Searches for a type with the given name in this model and creates a new type if no such type exists.
/// </summary>
/// <param name="qualifiedName">The qualified name of the type being found.</param>
/// <returns>The requested type, or the new type created if no such type exists.</returns>
IEdmSchemaType IEdmModel.FindDeclaredType(string qualifiedName)
{
CommonUtility.AssertNotNullOrEmpty("qualifiedName", qualifiedName);
if (qualifiedName.StartsWith(Constants.Edm, StringComparison.Ordinal))
{
// Primitive type, let the core model handle it.
return(null);
}
IEdmSchemaType schemaType = FindDeclaredType(qualifiedName);
if (schemaType == null)
{
string name;
string namespaceName;
SplitFullTypeName(qualifiedName, out name, out namespaceName);
// If no type is found with the given name, assume it is an open entity type with the normal set of properties.
schemaType = CreateEntityType(namespaceName, name);
this.AddElement(schemaType);
}
return(schemaType);
}
private List <string> GetEnumElements(IEdmSchemaType type, out bool isFlags)
{
var enumList = new List <string>();
isFlags = false;
if (type.TypeKind == EdmTypeKind.Enum)
{
if (type is IEdmEnumType enumType)
{
var list2 = enumType.Members;
isFlags = enumType.IsFlags;
foreach (var item in list2)
{
#if odataV3
var enumValue = ((EdmIntegerConstant)item.Value).Value;
var enumElement = $"\t\t{item.Name}={enumValue}";
#else
#if EDM7
//issue12 reserved keyword
var enumElement = $"\t\t{item.Name.ChangeReservedWord()}={item.Value.Value}";
//var enumElement = $"\t\t{item.Name}={item.Value.Value}";
#else
var enumValue = ((EdmIntegerConstant)item.Value).Value;
var enumElement = $"\t\t{item.Name.ChangeReservedWord()}={enumValue}";
//var enumElement = $"\t\t{item.Name}={enumValue}";
#endif
#endif
//enumList.Add(item.Name); // v2.3.0
enumList.Add(enumElement); //issue #7 complete enum name /value
}
}
}
return(enumList);
}
private static IEdmEntitySet FindEntitySet(IEdmModel model, IEdmSchemaType entityType)
{
var entitySets = model.EntityContainer.EntitySets().Where(s => entityType.IsOrInheritsFrom(s.EntityType()));
ExceptionUtilities.Assert(entitySets.Count() == 1, "Expected one entity set for entity type {0}. Found: {1}", entityType.Name, entitySets.Count());
return(entitySets.Single());
}
public static IEdmSchemaType ResolveType(this IEdmModel model, string typeName, bool enableCaseInsensitive = false)
{
IEdmSchemaType type = model.FindType(typeName);
if (type != null || !enableCaseInsensitive)
{
return(type);
}
var types = model.SchemaElements.OfType <IEdmSchemaType>()
.Where(e => string.Equals(typeName, e.FullName(), enableCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
foreach (var refModels in model.ReferencedModels)
{
var refedTypes = refModels.SchemaElements.OfType <IEdmSchemaType>()
.Where(e => string.Equals(typeName, e.FullName(), enableCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
types = types.Concat(refedTypes);
}
if (types.Count() > 1)
{
throw new Exception($"Multiple type found from the model for '{typeName}'.");
}
return(types.SingleOrDefault());
}
/// <summary>
/// Searches for a schema type with the given name in this model and returns null if no such schema element exists.
/// </summary>
/// <param name="qualifiedName">The qualified name of the schema element being found.</param>
/// <returns>The requested schema element, or null if no such schema element exists.</returns>
public IEdmSchemaType FindDeclaredType(string qualifiedName)
{
// NOTE: we only support entity types, complex types and primitive types
// (no association types)
IEdmSchemaType coreType = EdmCoreModel.Instance.FindDeclaredType(qualifiedName);
if (coreType != null)
{
return(null);
}
IEdmEntityType entityType;
if (this.entityTypes.TryGetValue(qualifiedName, out entityType))
{
return(entityType);
}
IEdmComplexType complexType;
if (this.complexTypes.TryGetValue(qualifiedName, out complexType))
{
return(complexType);
}
return(null);
}
/// <summary>
/// Add the Edm. prefix to the primitive type if there isn't.
/// </summary>
/// <param name="typeName">The type name which may be not prefixed (Edm.).</param>
/// <returns>The type name with Edm. prefix</returns>
internal static string AddEdmPrefixOfTypeName(string typeName)
{
if (!string.IsNullOrEmpty(typeName))
{
string itemTypeName = EdmLibraryExtensions.GetCollectionItemTypeName(typeName);
if (itemTypeName == null)
{
// This is the primitive type
IEdmSchemaType primitiveType = EdmLibraryExtensions.ResolvePrimitiveTypeName(typeName);
if (primitiveType != null)
{
return(primitiveType.FullName());
}
}
else
{
// This is the collection type
IEdmSchemaType primitiveType = EdmLibraryExtensions.ResolvePrimitiveTypeName(itemTypeName);
if (primitiveType != null)
{
return(EdmLibraryExtensions.GetCollectionTypeName(primitiveType.FullName()));
}
}
}
// Return the origin type name
return(typeName);
}
private List <PropertyTemplate> GetClassProperties(IEdmSchemaType ent)
{
//stop here if enum
if (ent is IEdmEnumType)
{
return(Enumerable.Empty <PropertyTemplate>().ToList()); //null;
}
var structuredType = ent as IEdmStructuredType;
var properties = structuredType.Properties();
if (_setting != null && _setting.UseInheritance)
{
#if odataV3
properties = properties.Where(x => ((IEdmSchemaType)x.DeclaringType).FullName() == ent.FullName());
#else
properties = properties.Where(x => x.DeclaringType.FullTypeName() == ent.FullTypeName());
#endif
}
//add serial for properties to support protbuf v3.0
var serial = 1;
var list = properties.Select(property => new PropertyTemplate
{
IsNullable = property.Type.IsNullable,
PropName = property.Name,
PropType = GetClrTypeName(property.Type),
Serial = serial++,
ClassNameSpace = ent.Namespace,
MaxLength = GetMaxLength(property),
IsReadOnly = Model.IsReadOnly(property),
//OriginalType = property.VocabularyAnnotations(Model),
}).ToList();
return(list);
}
public static string ToTraceString(this IEdmType type)
{
EdmUtil.CheckArgumentNull <IEdmType>(type, "type");
EdmTypeKind typeKind = type.TypeKind;
switch (typeKind)
{
case EdmTypeKind.Row:
{
return(((IEdmRowType)type).ToTraceString());
}
case EdmTypeKind.Collection:
{
return(((IEdmCollectionType)type).ToTraceString());
}
case EdmTypeKind.EntityReference:
{
return(((IEdmEntityReferenceType)type).ToTraceString());
}
default:
{
IEdmSchemaType edmSchemaType = type as IEdmSchemaType;
if (edmSchemaType == null)
{
break;
}
return(edmSchemaType.ToTraceString());
}
}
return("UnknownType");
}
/// <summary>
/// Prepare the type name for writing.
/// 1) If it is primitive type, remove the Edm. prefix.
/// 2) If it is a non-primitive type or 4.0, prefix with #.
/// </summary>
/// <param name="typeName">The type name to write</param>
/// <param name="version">OData Version of payload being written</param>
/// <returns>The type name for writing</returns>
internal static string PrefixTypeNameForWriting(string typeName, ODataVersion version)
{
if (!string.IsNullOrEmpty(typeName))
{
string itemTypeName = EdmLibraryExtensions.GetCollectionItemTypeName(typeName);
if (itemTypeName == null)
{
IEdmSchemaType primitiveType = EdmLibraryExtensions.ResolvePrimitiveTypeName(typeName);
if (primitiveType != null)
{
typeName = primitiveType.ShortQualifiedName();
return(version < ODataVersion.V401 ? PrefixTypeName(typeName) : typeName);
}
}
else
{
IEdmSchemaType primitiveType = EdmLibraryExtensions.ResolvePrimitiveTypeName(itemTypeName);
if (primitiveType != null)
{
typeName = EdmLibraryExtensions.GetCollectionTypeName(primitiveType.ShortQualifiedName());
return(version < ODataVersion.V401 ? PrefixTypeName(typeName) : typeName);
}
}
}
return(PrefixTypeName(typeName));
}
private List <PropertyTemplate> GetClassProperties(IEdmSchemaType ent)
{
//stop here if enum
if (ent is IEdmEnumType)
{
return(null);
}
var structuredType = ent as IEdmStructuredType;
var properties = structuredType.Properties();
if (_setting.UseInheritance)
{
#if odataV3
properties = properties.Where(x => ((IEdmSchemaType)x.DeclaringType).FullName() == ent.FullName());
#else
properties = properties.Where(x => x.DeclaringType.FullTypeName() == ent.FullTypeName());
#endif
}
//add serial for properties to support protbuf v3.0
var serial = 1;
var list = properties.Select(property => new PropertyTemplate
{
IsNullable = property.Type.IsNullable,
PropName = property.Name,
PropType = GetClrTypeName(property.Type),
Serial = serial++
}).ToList();
return(list);
}
protected string RemoveEdmPrefixFromTypeName(string typeName)
{
string itemTypeName = GetCollectionItemTypeName(typeName);
if (itemTypeName == null)
{
// This is not a collection type
IEdmSchemaType edmType = EdmCoreModel.Instance.FindDeclaredType(typeName);
if (edmType != null)
{
return(edmType.ShortQualifiedName());
}
}
else
{
// This is a collection type
IEdmSchemaType edmType = EdmCoreModel.Instance.FindDeclaredType(itemTypeName);
if (edmType != null)
{
return(CollectionTypeQualifier + String.Format("({0})", edmType.ShortQualifiedName()));
}
}
return(typeName);
}
public void WriteToStreamAsync_SetsMetadataUriWithSelectClause_OnODataWriterSettings()
{
// Arrange
MemoryStream stream = new MemoryStream();
StreamContent content = new StreamContent(stream);
content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
IEdmModel model = CreateModel();
IEdmSchemaType entityType = model.FindDeclaredType("System.Net.Http.Formatting.SampleType");
IEdmStructuralProperty property =
((IEdmStructuredType)entityType).FindProperty("Number") as IEdmStructuralProperty;
HttpRequestMessage request = CreateFakeODataRequest(model);
request.RequestUri = new Uri("http://localhost/sampleTypes?$select=Number");
request.ODataProperties().SelectExpandClause =
new SelectExpandClause(
new Collection <SelectItem>
{
new PathSelectItem(new ODataSelectPath(new PropertySegment(property))),
},
allSelected: false);
ODataMediaTypeFormatter formatter = CreateFormatter(model, request, ODataPayloadKind.Resource);
// Act
formatter.WriteToStreamAsync(typeof(SampleType[]), new SampleType[0], stream, content, transportContext: null);
// Assert
stream.Seek(0, SeekOrigin.Begin);
string result = content.ReadAsStringAsync().Result;
JObject obj = JObject.Parse(result);
Assert.Equal("http://localhost/$metadata#sampleTypes(Number)", obj["@odata.context"]);
}
/// <summary>
/// Resolve the <see cref="IEdmSchemaType"/> using the type name. This method supports the type name case insensitive.
/// </summary>
/// <param name="model">The Edm model.</param>
/// <param name="typeName">The type name.</param>
/// <returns>The Edm schema type.</returns>
public static IEdmSchemaType ResolveType(this IEdmModel model, string typeName)
{
IEdmSchemaType type = model.FindType(typeName);
if (type != null)
{
return(type);
}
var types = model.SchemaElements.OfType <IEdmSchemaType>()
.Where(e => string.Equals(typeName, e.FullName(), StringComparison.OrdinalIgnoreCase));
foreach (var refModels in model.ReferencedModels)
{
var refedTypes = refModels.SchemaElements.OfType <IEdmSchemaType>()
.Where(e => string.Equals(typeName, e.FullName(), StringComparison.OrdinalIgnoreCase));
types = types.Concat(refedTypes);
}
if (types.Count() > 1)
{
throw new ODataException(Error.Format(SRResources.AmbiguousTypeNameFound, typeName));
}
return(types.SingleOrDefault());
}
/// <summary>
/// Binds a DottedIdentifierToken and it's parent node (if needed).
/// </summary>
/// <param name="dottedIdentifierToken">Token to bind to metadata.</param>
/// <param name="state">State of the Binding.</param>
/// <returns>A bound node representing the cast.</returns>
internal QueryNode BindDottedIdentifier(DottedIdentifierToken dottedIdentifierToken, BindingState state)
{
DebugUtils.CheckNoExternalCallers();
ExceptionUtils.CheckArgumentNotNull(dottedIdentifierToken, "castToken");
ExceptionUtils.CheckArgumentNotNull(state, "state");
QueryNode parent;
IEdmType parentType;
if (dottedIdentifierToken.NextToken == null)
{
parent = NodeFactory.CreateRangeVariableReferenceNode(state.ImplicitRangeVariable);
parentType = state.ImplicitRangeVariable.TypeReference.Definition;
}
else
{
parent = this.bindMethod(dottedIdentifierToken.NextToken);
parentType = parent.GetEdmType();
}
SingleEntityNode parentAsSingleValue = parent as SingleEntityNode;
IEdmSchemaType childType = UriEdmHelpers.FindTypeFromModel(state.Model, dottedIdentifierToken.Identifier);
IEdmEntityType childEntityType = childType as IEdmEntityType;
if (childEntityType == null)
{
FunctionCallBinder functionCallBinder = new FunctionCallBinder(bindMethod);
QueryNode functionCallNode;
if (functionCallBinder.TryBindDottedIdentifierAsFunctionCall(dottedIdentifierToken, parentAsSingleValue, state, out functionCallNode))
{
return(functionCallNode);
}
else
{
throw new ODataException(ODataErrorStrings.CastBinder_ChildTypeIsNotEntity(dottedIdentifierToken.Identifier));
}
}
// Check whether childType is a derived type of the type of its parent node
UriEdmHelpers.CheckRelatedTo(parentType, childType);
EntityCollectionNode parentAsCollection = parent as EntityCollectionNode;
if (parentAsCollection != null)
{
return(new EntityCollectionCastNode(parentAsCollection, childEntityType));
}
// parent can be null for casts on the implicit parameter; this is OK
if (parent == null)
{
return(new SingleEntityCastNode(null, childEntityType));
}
Debug.Assert(parentAsSingleValue != null, "If parent of the cast node was not collection, it should be a single value.");
return(new SingleEntityCastNode(parentAsSingleValue, childEntityType));
}
private string ProcessComplexType(IEdmSchemaType complexType)
{
StringBuilder str = new StringBuilder();
var structuredType = complexType as IEdmStructuredType;
var properties = structuredType.Properties();
str.Append(complexType.Name);
return(str.ToString());
}
internal static string FullyQualifiedName(IEdmVocabularyAnnotatable element)
{
IEdmSchemaElement schemaElement = element as IEdmSchemaElement;
if (schemaElement != null)
{
IEdmOperation operation = schemaElement as IEdmOperation;
if (operation != null)
{
return(ParameterizedName(operation));
}
else
{
return(schemaElement.FullName());
}
}
else
{
IEdmEntityContainerElement containerElement = element as IEdmEntityContainerElement;
if (containerElement != null)
{
return(containerElement.Container.FullName() + "/" + containerElement.Name);
}
else
{
IEdmProperty property = element as IEdmProperty;
if (property != null)
{
IEdmSchemaType declaringSchemaType = property.DeclaringType as IEdmSchemaType;
if (declaringSchemaType != null)
{
string propertyOwnerName = FullyQualifiedName(declaringSchemaType);
if (propertyOwnerName != null)
{
return(propertyOwnerName + "/" + property.Name);
}
}
}
else
{
IEdmOperationParameter parameter = element as IEdmOperationParameter;
if (parameter != null)
{
string parameterOwnerName = FullyQualifiedName(parameter.DeclaringOperation);
if (parameterOwnerName != null)
{
return(parameterOwnerName + "/" + parameter.Name);
}
}
}
}
}
return(null);
}
/// <summary>
/// Get the item type full name if it's the primitive type
/// </summary>
/// <param name="typeName">the original type name</param>
/// <returns>the item type full name if it's the primitive type</returns>
private static string GetItemTypeFullName(string typeName)
{
IEdmSchemaType knownType = EdmCoreModel.Instance.FindDeclaredType(typeName);
if (knownType != null)
{
return(knownType.FullName());
}
return(typeName);
}
public static Type GetClrType(IEdmType edmType, IEdmModel edmModel, IAssemblyProvider assemblyProvider)
{
IEdmSchemaType edmSchemaType = edmType as IEdmSchemaType;
Contract.Assert(edmSchemaType != null);
string typeName = edmSchemaType.FullName();
IEnumerable <Type> matchingTypes = GetMatchingTypes(typeName, assemblyProvider);
return(matchingTypes.FirstOrDefault());
}
public IEdmSchemaType FindDeclaredType(string qualifiedName)
{
foreach (var innerContainer in _innerContainers)
{
IEdmSchemaType edmType = innerContainer.EdmModel.FindDeclaredType(qualifiedName);
if (edmType != null)
{
return(edmType);
}
}
return(null);
}
private static EdmTypeKind ComputeExpectedTypeKind(string typeName, out IEdmPrimitiveType primitiveItemType)
{
IEdmSchemaType type = EdmCoreModel.Instance.FindDeclaredType(typeName);
if (type != null)
{
primitiveItemType = (IEdmPrimitiveType)type;
return(EdmTypeKind.Primitive);
}
primitiveItemType = null;
return(EdmTypeKind.Complex);
}
private List <string> GetNavigation(IEdmSchemaType ent)
{
var list = new List <string>();
if (ent is IEdmEntityType entityType)
{
var nav = entityType.DeclaredNavigationProperties().ToList();
list.AddRange(nav.Select(key => key.Name));
}
return(list);
}
public static IEntitySetMetadata GetEntitySetFor(this IContainerMetadata containerMetadata, IEdmSchemaType edmSchemaType)
{
Contract.Requires<ArgumentNullException>(containerMetadata != null);
Contract.Requires<ArgumentNullException>(edmSchemaType != null);
IEntityTypeMetadata entityType = GetEntityType(containerMetadata, edmSchemaType);
if (entityType == null)
{
return null;
}
return containerMetadata.EntitySets.SingleOrDefault(es => es.ElementTypeHierarchyMetadata.Contains(entityType));
}
internal static IEdmSchemaType CreateAmbiguousTypeBinding(IEdmSchemaType first, IEdmSchemaType second)
{
var ambiguous = first as AmbiguousTypeBinding;
if (ambiguous != null)
{
ambiguous.AddBinding(second);
return(ambiguous);
}
return(new AmbiguousTypeBinding(first, second));
}
protected string GetCyclicBaseTypeName(string baseTypeName)
{
IEdmSchemaType edmSchemaType = this.context.FindType(baseTypeName);
if (edmSchemaType != null)
{
return(edmSchemaType.FullName());
}
else
{
return(baseTypeName);
}
}
public static IEntityTypeMetadata GetEntityType(this IContainerMetadata containerMetadata, IEdmSchemaType edmSchemaType)
{
Contract.Requires<ArgumentNullException>(containerMetadata != null);
Contract.Requires<ArgumentNullException>(edmSchemaType != null);
return containerMetadata.EntityTypes.SingleOrDefault(et =>
{
IEdmEntityType edmType = et.EdmType;
return edmType.TypeKind == edmSchemaType.TypeKind
&& edmType.Name == edmSchemaType.Name
&& ((edmType.Namespace == edmSchemaType.Namespace) || (containerMetadata.Namespace == edmSchemaType.Namespace) || (et.ClrType.Namespace == edmSchemaType.Namespace));
});
}
private List<string> GetEnumElements(IEdmSchemaType type)
{
List<string> enumList = new List<string>();
if (type.TypeKind == EdmTypeKind.Enum)
{
var enumType = type as IEdmEnumType;
if (enumType != null)
{
var list2 = enumType.Members;
foreach (var item in list2)
{
Debug.WriteLine("GetEnumElements- name: [{0}] ", (object)item.Name);
enumList.Add(item.Name);
}
}
}
return enumList;
}
private ClassTemplate GeneratePocoClass(IEdmSchemaType ent)
{
if (ent == null) return null;
//for debuging
// var debugString = Helper.Dump(ent);
//v1.0.0-rc3 , enum support
var enumType = ent as IEdmEnumType;
ClassTemplate classTemplate = new ClassTemplate
{
Name = ent.Name,
// ToDebugString = debugString,
IsEnum = (enumType != null)
};
//for enum type , stop here , no more information needed
if (classTemplate.IsEnum) return classTemplate;
//fill setname
//v1.4
classTemplate.EntitySetName = GetEntitySetName(ent.Name);
//fill keys
var list = GetKeys(ent);
if (list != null) classTemplate.Keys.AddRange(list);
//fill navigation properties
var list2 = GetNavigation(ent);
if (list2 != null) classTemplate.Navigation.AddRange(list2);
var entityProperties = GetClassProperties(ent);
//set the key ,comment
foreach (var property in entityProperties)
{
//@@@ v1.0.0-rc3
if (classTemplate.Navigation.Exists(x => x == property.PropName)) property.IsNavigate = true;
if (classTemplate.Keys.Exists(x => x == property.PropName)) property.IsKey = true;
var comment = (property.IsKey ? "PrimaryKey" : String.Empty)
+ (property.IsNullable ? String.Empty : " not null");
if (!string.IsNullOrEmpty(comment)) property.PropComment = "//" + comment;
}
classTemplate.Properties.AddRange(entityProperties);
return classTemplate;
}
/// <summary>
/// Adds a schema type to the internal caches of the model.
/// </summary>
/// <param name="schemaType">The <see cref="IEdmSchemaType"/> to cache.</param>
/// <remarks>
/// Materialization state: none required. No change in materialization state.
/// Cache state: none required. No change in cache state.
/// </remarks>
private void CacheSchemaType(IEdmSchemaType schemaType)
{
Debug.Assert(schemaType != null, "schemaType != null");
// first add the schema element to the schema element cache
string fullName = schemaType.FullName();
Debug.Assert(!this.schemaTypeCache.ContainsKey(fullName), "Schema type cache already contains an element with name " + fullName + ".");
this.schemaTypeCache.Add(fullName, schemaType);
IEdmStructuredType structuredType = schemaType as IEdmStructuredType;
if (structuredType != null && structuredType.BaseType != null)
{
List<IEdmStructuredType> derivedTypes;
if (!this.derivedTypeMappings.TryGetValue(structuredType.BaseType, out derivedTypes))
{
derivedTypes = new List<IEdmStructuredType>();
this.derivedTypeMappings[structuredType.BaseType] = derivedTypes;
}
derivedTypes.Add(structuredType);
}
}
private List<string> GetNavigation(IEdmSchemaType ent)
{
var list = new List<string>();
var entityType = ent as IEdmEntityType;
if (entityType != null)
{
var nav = entityType.DeclaredNavigationProperties().ToList();
list.AddRange(nav.Select(key => key.Name));
}
return list;
}
private List<string> GetKeys(IEdmSchemaType ent)
{
var list = new List<string>();
var entityType = ent as IEdmEntityType;
if (entityType != null)
{
var keys = entityType.DeclaredKey;
if (keys != null)
list.AddRange(keys.Select(key => key.Name));
}
return list;
}
private void CacheSchemaType(IEdmSchemaType schemaType)
{
string key = schemaType.FullName();
this.schemaTypeCache.Add(key, schemaType);
IEdmStructuredType item = schemaType as IEdmStructuredType;
if ((item != null) && (item.BaseType != null))
{
List<IEdmStructuredType> list;
if (!this.derivedTypeMappings.TryGetValue(item.BaseType, out list))
{
list = new List<IEdmStructuredType>();
this.derivedTypeMappings[item.BaseType] = list;
}
list.Add(item);
}
}
private List<PropertyTemplate> GetClassProperties(IEdmSchemaType ent)
{
//stop here for enum
var enumType = ent as IEdmEnumType;
if (enumType != null) return null;
var structuredType = ent as IEdmStructuredType;
var properties = structuredType.Properties();
var list = properties.Select(property => new PropertyTemplate
{
//ToTrace = property.ToTraceString(),
IsNullable = property.Type.IsNullable,
PropName = property.Name,
PropType = GetClrTypeName(property.Type),
//ToDebugString = Helper.Dump(property)
}).ToList();
return list;
}
private static bool IsEquivalentTo(this IEdmSchemaType thisType, IEdmSchemaType otherType)
{
return Object.ReferenceEquals(thisType, otherType);
}
private static void CheckForUnreacheableTypeError(ValidationContext context, IEdmSchemaType type, EdmLocation location)
{
IEdmType foundType = context.Model.FindType(type.FullName());
if (foundType is AmbiguousTypeBinding)
{
context.AddError(
location,
EdmErrorCode.BadAmbiguousElementBinding,
Strings.EdmModel_Validator_Semantic_AmbiguousType(type.FullName()));
}
else if (!foundType.IsEquivalentTo(type))
{
context.AddError(
location,
EdmErrorCode.BadUnresolvedType,
Strings.EdmModel_Validator_Semantic_InaccessibleType(type.FullName()));
}
}
private void AnnotateElement(IEdmSchemaType schemaElement, Uri elementId)
{
_annotationsManager.SetAnnotationValue(schemaElement, AnnotationNamespace, AnnotationAttribute, elementId);
}
private static IEdmEntitySet FindEntitySet(IEdmModel model, IEdmSchemaType entityType)
{
var entitySets = model.EntityContainer.EntitySets().Where(s => entityType.IsOrInheritsFrom(s.EntityType()));
ExceptionUtilities.Assert(entitySets.Count() == 1, "Expected one entity set for entity type {0}. Found: {1}", entityType.Name, entitySets.Count());
return entitySets.Single();
}
