public Task<IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var model = new EdmModel();
var dummyType = new EdmEntityType("NS", "Dummy");
model.AddElement(dummyType);
var container = new EdmEntityContainer("NS", "DefaultContainer");
container.AddEntitySet("Test", dummyType);
model.AddElement(container);
return Task.FromResult((IEdmModel) model);
}
public void ResolveNavigationSource_ThrowsODataException_AmbiguousIdentifier()
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "Entity");
EdmEntityContainer containter = new EdmEntityContainer("NS", "Default");
model.AddElement(entityType);
model.AddElement(containter);
containter.AddEntitySet("entities", entityType);
containter.AddEntitySet("enTIties", entityType);
// Act & Assert
Assert.NotNull(model.ResolveNavigationSource("enTIties"));
Assert.NotNull(model.ResolveNavigationSource("enTIties", true));
// Act & Assert
Assert.Null(model.ResolveNavigationSource("Entities"));
Action test = () => model.ResolveNavigationSource("Entities", true);
ExceptionAssert.Throws <ODataException>(test,
"Ambiguous navigation source (entity set or singleton) name 'Entities' found. Please use correct navigation source name case.");
}
public Task <EdmModel> ProduceModelAsync(
ModelContext context,
CancellationToken cancellationToken)
{
var model = new EdmModel();
var entityType = new EdmEntityType(
"TestNamespace", "TestName");
var entityContainer = new EdmEntityContainer(
"TestNamespace", "Entities");
entityContainer.AddEntitySet("TestEntitySet", entityType);
model.AddElement(entityType);
model.AddElement(entityContainer);
return(Task.FromResult(model));
}
private static IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
// Customer
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("FirstName", EdmPrimitiveTypeKind.String),
customer.AddStructuralProperty("LastName", EdmPrimitiveTypeKind.String));
model.AddElement(customer);
// VipCustomer
EdmEntityType vipCustomer = new EdmEntityType("NS", "VipCustomer", customer);
model.AddElement(vipCustomer);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
container.AddEntitySet("Customers", customer);
container.AddEntitySet("AnotherCustomers", customer);
container.AddEntitySet("CaseInsensitiveCustomers", customer);
model.AddElement(container);
return(model);
}
static KeySegmentTemplateTests()
{
// EntityType
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty idProperty = customerType.AddStructuralProperty("customerId", EdmPrimitiveTypeKind.Int32);
customerType.AddKeys(idProperty);
_customerType = customerType;
// EntitySet
EdmEntityContainer container = new EdmEntityContainer("NS", "default");
_customers = container.AddEntitySet("Customers", customerType);
_container = container;
}
private static EdmModel CreatePersonModelWithTypeDefinition(out IEdmEntitySet entitySet)
{
var model = new EdmModel();
var uint32 = model.GetUInt32("DefaultNamespace", false);
var container = new EdmEntityContainer("DefaultNamespace", "Container");
var personType = new EdmEntityType("DefaultNamespace", "Person");
var keyProp = personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
personType.AddStructuralProperty("Numbers", new EdmCollectionTypeReference(new EdmCollectionType(uint32)));
personType.AddKeys(keyProp);
entitySet = container.AddEntitySet("People", personType);
model.AddElement(container);
model.AddElement(personType);
return(model);
}
public void TryTranslateKeySegmentTemplate_WorksWithKeyValue_UsingEscapedString()
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty firstName = customerType.AddStructuralProperty("FirstName", EdmPrimitiveTypeKind.String);
EdmStructuralProperty lastName = customerType.AddStructuralProperty("LastName", EdmPrimitiveTypeKind.String);
customerType.AddKeys(firstName, lastName);
model.AddElement(customerType);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet customers = container.AddEntitySet("Customers", customerType);
model.AddElement(container);
RouteValueDictionary routeValueDictionary = new RouteValueDictionary(new { First = "'Zhang'", Last = "'Gan%2Fnng%23%20T'" });
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "FirstName", "{first}" },
{ "LastName", "{last}" }
};
KeySegmentTemplate template = new KeySegmentTemplate(keys, customerType, customers);
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
RouteValues = routeValueDictionary,
Model = model
};
// Act
bool ok = template.TryTranslate(context);
// Assert
Assert.True(ok);
ODataPathSegment actual = Assert.Single(context.Segments);
KeySegment keySegment = Assert.IsType <KeySegment>(actual);
Assert.Collection(keySegment.Keys,
e =>
{
Assert.Equal("FirstName", e.Key);
Assert.Equal("Zhang", e.Value);
},
e =>
{
Assert.Equal("LastName", e.Key);
Assert.Equal("Gan/nng# T", e.Value);
});
}
public void GetModel(EdmModel model, EdmEntityContainer container)
{
foreach (var tableName in _tableList.DbTables)
{
EdmEntityType tableType = new EdmEntityType(EdmNamespaceName, tableName);
var edmType = EdmTypeUtil.DbTypeToEdmType("nvarchar");
if (edmType.HasValue)
{
tableType.AddStructuralProperty("Column1", edmType.Value);
tableType.AddStructuralProperty("Column2", edmType.Value);
}
model.AddElement(tableType);
container.AddEntitySet(tableName, tableType);
}
}
public void ODataPathSegmentHandler_Handles_EntitySetSegment()
{
// Arrange
ODataPathSegmentHandler handler = new ODataPathSegmentHandler();
EdmEntityContainer entityContainer = new EdmEntityContainer("NS", "Default");
EdmEntityType customer = new EdmEntityType("NS", "Customer");
EdmEntitySet customers = entityContainer.AddEntitySet("Customers", customer);
EntitySetSegment segment = new EntitySetSegment(customers);
// Act
handler.Handle(segment);
// Assert
Assert.Equal("Customers", handler.PathLiteral);
Assert.Same(customers, handler.NavigationSource);
}
//// TODO: Add in-stream error tests
/// <summary>
/// Creates an empty model so that the JSON lite serializer won't complain.
/// </summary>
/// <param name="entitySet">An entity set in the generated model.</param>
private EdmModel CreateErrorTestModel(out EdmEntitySet entitySet)
{
EdmModel model = new EdmModel();
var customer = new EdmEntityType("TestModel", "Customer");
model.AddElement(customer);
var container = new EdmEntityContainer("TestModel", "DefaultContainer");
model.AddElement(container);
entitySet = container.AddEntitySet("Customers", customer);
return(model);
}
public void ODataPathSegmentToTemplateHandler_Throws_BatchReferenceSegment()
{
// Arrange
ODataPathSegmentToTemplateHandler handler = new ODataPathSegmentToTemplateHandler(null);
EdmEntityContainer entityContainer = new EdmEntityContainer("NS", "Default");
EdmEntityType customer = new EdmEntityType("NS", "Customer");
EdmEntitySet customers = entityContainer.AddEntitySet("Customers", customer);
BatchReferenceSegment segment = new BatchReferenceSegment("$4", customer, customers);
// Act
Action test = () => handler.Handle(segment);
// Assert
ExceptionAssert.Throws <ODataException>(test, "'ODataPathSegment' of kind 'BatchReferenceSegment' is not implemented.");
}
public void UnqualifiedTypeNameShouldNotBeTreatedAsTypeCast()
{
var model = new EdmModel();
var entityType = new EdmEntityType("NS", "Entity");
entityType.AddKeys(entityType.AddStructuralProperty("IdStr", EdmPrimitiveTypeKind.String, false));
var container = new EdmEntityContainer("NS", "Container");
var set = container.AddEntitySet("Set", entityType);
model.AddElements(new IEdmSchemaElement[] { entityType, container });
var svcRoot = new Uri("http://host", UriKind.Absolute);
var parseResult = new ODataUriParser(model, svcRoot, new Uri("http://host/Set/Date", UriKind.Absolute)).ParseUri();
Assert.True(parseResult.Path.LastSegment is KeySegment);
}
public void GetTemplatesWorksForPathWithTypeCastAndFunction()
{
// Arrange
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
// VipCustomer
EdmEntityType vipCustomer = new EdmEntityType("NS", "VipCustomer", customer);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
var entitySet = container.AddEntitySet("Customers", customer);
// function with optional parameters
EdmFunction getSalaray = new EdmFunction("NS", "GetWholeSalary", IntType, isBound: true, entitySetPathExpression: null, isComposable: false);
getSalaray.AddParameter("entityset", new EdmEntityTypeReference(vipCustomer, false));
getSalaray.AddParameter("salary", IntType);
getSalaray.AddOptionalParameter("minSalary", IntType);
getSalaray.AddOptionalParameter("maxSalary", IntType, "129");
ODataPathTemplate template = new ODataPathTemplate(
new EntitySetSegmentTemplate(entitySet),
KeySegmentTemplate.CreateKeySegment(customer, entitySet),
new CastSegmentTemplate(vipCustomer, customer, entitySet),
new FunctionSegmentTemplate(getSalaray, null));
// Act
IEnumerable <(string, string)> actual = template.GetTemplates();
Assert.Equal(4, actual.Count());
Assert.Equal(new[]
{
"Customers({key})/NS.VipCustomer/NS.GetWholeSalary({salary;minSalary;maxSalary})",
"Customers({key})/NS.VipCustomer/GetWholeSalary({salary;minSalary;maxSalary})",
"Customers/{key}/NS.VipCustomer/NS.GetWholeSalary({salary;minSalary;maxSalary})",
"Customers/{key}/NS.VipCustomer/GetWholeSalary({salary;minSalary;maxSalary})",
}, actual.Select(a => a.Item1));
Assert.Equal(new[]
{
"Customers({key})/NS.VipCustomer/NS.GetWholeSalary(salary={salary},minSalary={minSalary},maxSalary={maxSalary})",
"Customers({key})/NS.VipCustomer/GetWholeSalary(salary={salary},minSalary={minSalary},maxSalary={maxSalary})",
"Customers/{key}/NS.VipCustomer/NS.GetWholeSalary(salary={salary},minSalary={minSalary},maxSalary={maxSalary})",
"Customers/{key}/NS.VipCustomer/GetWholeSalary(salary={salary},minSalary={minSalary},maxSalary={maxSalary})",
}, actual.Select(a => a.Item2));
}
private static IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
// Address
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// CnAddess
EdmComplexType cnAddress = new EdmComplexType("NS", "CnAddress", address);
cnAddress.AddStructuralProperty("Postcode", EdmPrimitiveTypeKind.String);
model.AddElement(cnAddress);
// UsAddress
EdmComplexType usAddress = new EdmComplexType("NS", "UsAddress", address);
usAddress.AddStructuralProperty("Zipcode", EdmPrimitiveTypeKind.Int32);
model.AddElement(usAddress);
// Customer
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customer.AddStructuralProperty("Emails", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, false))));
customer.AddStructuralProperty("Address", new EdmComplexTypeReference(address, false));
customer.AddStructuralProperty("Locations", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(address, false))));
model.AddElement(customer);
// VipCustomer
EdmEntityType vipCustomer = new EdmEntityType("NS", "VipCustomer", customer);
vipCustomer.AddStructuralProperty("SubAddress", new EdmComplexTypeReference(address, false));
vipCustomer.AddStructuralProperty("SubLocations", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(address, false))));
model.AddElement(vipCustomer);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
container.AddEntitySet("Customers", customer);
container.AddSingleton("Me", customer);
model.AddElement(container);
return(model);
}
private static IEdmModel CreateCompositeKeyModel()
{
var model = new EdmModel();
var customer = new EdmEntityType("NS", "Customer", null, false, true);
var customerId = customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
var customerName = customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String, true);
customer.AddKeys(customerId, customerName);
model.AddElement(customer);
var container = new EdmEntityContainer("NS", "Container");
var customers = container.AddEntitySet("Customers", customer);
model.AddElement(container);
return(model);
}
private static EdmModel BuildModel()
{
var model = new EdmModel();
var personType = new EdmEntityType("NS", "Person");
personType.AddKeys(personType.AddStructuralProperty("PersonId", EdmPrimitiveTypeKind.Int32));
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(personType);
var container = new EdmEntityContainer("NS", "Container");
container.AddEntitySet("People", personType);
model.AddElement(container);
return(model);
}
/// <summary>
/// Create a model
/// </summary>
/// <param name="entityTyps"></param>
/// <returns></returns>
public static EdmModel CreateModel(Type[] entityTyps)
{
var model = new EdmModel();
var container = new EdmEntityContainer("System.Web.OData.Aggregation.Tests.Common", "container");
model.AddElement(container);
foreach (var clrType in entityTyps)
{
EdmStructuredType edmType;
if (clrType == entityTyps.Last())
{
edmType = new EdmEntityType(clrType.Namespace, clrType.Name);
container.AddEntitySet(clrType.Name, edmType as IEdmEntityType);
}
else
{
edmType = new EdmComplexType(clrType.Namespace, clrType.Name);
}
foreach (var pi in clrType.GetProperties())
{
if (pi.PropertyType.IsPrimitive || pi.PropertyType.FullName == "System.String" || pi.PropertyType.FullName == "System.DateTimeOffset" || pi.PropertyType.FullName == "System.DateTime" || pi.PropertyType.IsEnum)
{
edmType.AddStructuralProperty(
pi.Name,
GetPrimitiveTypeKind(pi.PropertyType),
true);
}
else
{
var propEdmType = model.FindDeclaredType(pi.PropertyType.FullName);
if (propEdmType != null)
{
edmType.AddStructuralProperty(
pi.Name,
propEdmType.ToEdmTypeReference(true));
}
}
}
model.AddElement(edmType as IEdmSchemaElement);
}
return(model);
}
public FeedAnnotationIntegrationTests()
{
EdmModel tmp = new EdmModel();
this.type = new EdmEntityType("Namespace", "Type");
this.type.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = this.type, TargetMultiplicity = EdmMultiplicity.Many, Name = "NavProp"
});
this.type.AddProperty(new EdmStructuralProperty(this.type, "PrimitiveProp", EdmCoreModel.Instance.GetInt32(false)));
tmp.AddElement(this.type);
EdmEntityContainer edmEntityContainer = new EdmEntityContainer("Namespace", "Container_sub");
this.entitySet = edmEntityContainer.AddEntitySet("EntitySet", this.type);
tmp.AddElement(edmEntityContainer);
this.model = TestUtils.WrapReferencedModelsToMainModel("Namespace", "Container", tmp);
}
public void ReadNullableCollectionValue()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "MyTestEntity");
EdmStructuralProperty key = entityType.AddStructuralProperty("LongId", EdmPrimitiveTypeKind.Int64, false);
entityType.AddKeys(key);
entityType.AddStructuralProperty("NullableIntNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(true))));
model.AddElement(entityType);
EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer_sub");
EdmEntitySet entitySet = container.AddEntitySet("MyTestEntitySet", entityType);
model.AddElement(container);
const string payload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.MyTestEntitySet/$entity\"," +
"\"@odata.id\":\"http://mytest\"," +
"\"NullableIntNumbers\":[0,null,1,2]" +
"}";
IEdmModel mainModel = TestUtils.WrapReferencedModelsToMainModel("EntityNs", "MyContainer", model);
ODataResource entry = null;
this.ReadEntryPayload(mainModel, payload, entitySet, entityType, reader => { entry = entry ?? reader.Item as ODataResource; });
Assert.NotNull(entry);
var intCollection = entry.Properties.FirstOrDefault(
s => string.Equals(
s.Name,
"NullableIntNumbers",
StringComparison.OrdinalIgnoreCase)).Value.As <ODataCollectionValue>();
var list = new List <int?>();
foreach (var val in intCollection.Items)
{
list.Add(val as int?);
}
Assert.Equal(0, list[0]);
Assert.Null(list[1]);
Assert.Equal(1, (int)list[2]);
Assert.Equal(2, (int)list[3]);
}
private EdmModel GetModel()
{
EdmModel model = new EdmModel();
EdmEntityType edmEntityType = new EdmEntityType("NS", "Person");
edmEntityType.AddKeys(edmEntityType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.String));
edmEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "Dogs", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = edmEntityType
});
model.AddElement(edmEntityType);
EdmEntityContainer container = new EdmEntityContainer("NS", "EntityContainer");
model.AddElement(container);
container.AddEntitySet("People", edmEntityType);
return(model);
}
public void TryTranslateKeySegmentTemplate_ReturnsODataKeySegment_ForKeyAsSegment()
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty idProperty = customerType.AddStructuralProperty("customerId", EdmPrimitiveTypeKind.String);
customerType.AddKeys(idProperty);
model.AddElement(customerType);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet customers = container.AddEntitySet("Customers", customerType);
model.AddElement(container);
RouteValueDictionary routeValueDictionary = new RouteValueDictionary(new { key = "Peter" });
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "customerId", "{key}" }
};
KeySegmentTemplate template = new KeySegmentTemplate(keys, customerType, customers);
RouteEndpoint endpoint = new RouteEndpoint(
c => Task.CompletedTask,
RoutePatternFactory.Parse("odata/customers/{key}/Name"),
0,
EndpointMetadataCollection.Empty,
"test");
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
RouteValues = routeValueDictionary,
Model = model,
Endpoint = endpoint
};
// Act
bool ok = template.TryTranslate(context);
// Assert
Assert.True(ok);
ODataPathSegment actual = Assert.Single(context.Segments);
KeySegment keySegment = Assert.IsType <KeySegment>(actual);
KeyValuePair <string, object> actualKeys = Assert.Single(keySegment.Keys);
Assert.Equal("customerId", actualKeys.Key);
Assert.Equal("Peter", actualKeys.Value);
}
private void InitializeEdmModel()
{
this.model = new EdmModel();
var productEntityType = new EdmEntityType("NS", "Product");
var productIdProperty = productEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
productEntityType.AddKeys(productIdProperty);
productEntityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
this.model.AddElement(productEntityType);
var entityContainer = new EdmEntityContainer("NS", "Container");
this.model.AddElement(entityContainer);
entityContainer.AddEntitySet("Products", productEntityType);
}
public IEdmModel GetEdmModel(string connectionString)
{
EdmModel model = new EdmModel();
// create and add entity container
EdmEntityContainer container = new EdmEntityContainer("NS", "DefaultContainer");
model.AddElement(container);
using (var cnn = new SqlConnection(connectionString))
using (var dbReader = new DatabaseReader(cnn))
{
var schema = dbReader.ReadAll();
foreach (var table in schema.Tables)
{
if (table.Name.EndsWith("_Archive"))
{
continue;
}
var tableType = new EdmEntityType("NS", table.Name);
foreach (var col in table.Columns)
{
var kind = GetKind(col);
if (!kind.HasValue)
{
continue;
}
var prop = tableType.AddStructuralProperty(col.Name, kind.Value, col.Nullable);
if (col.IsPrimaryKey)
{
tableType.AddKeys(prop);
}
}
model.AddElement(tableType);
container.AddEntitySet(table.Name, tableType);
}
}
return(model);
}
private static IEdmModel BuildEdmModel()
{
var entityType = new EdmEntityType("Squidex", "Asset");
void AddProperty(string name, EdmPrimitiveTypeKind type)
{
entityType.AddStructuralProperty(name.ToCamelCase(), type);
}
void AddPropertyReference(string name, IEdmTypeReference reference)
{
entityType.AddStructuralProperty(name.ToCamelCase(), reference);
}
var jsonType = new EdmComplexType("Squidex", "Json", null, false, true);
AddPropertyReference("Metadata", new EdmComplexTypeReference(jsonType, false));
AddProperty("id", EdmPrimitiveTypeKind.String);
AddProperty("version", EdmPrimitiveTypeKind.Int64);
AddProperty("created", EdmPrimitiveTypeKind.DateTimeOffset);
AddProperty("createdBy", EdmPrimitiveTypeKind.String);
AddProperty("fileHash", EdmPrimitiveTypeKind.String);
AddProperty("fileName", EdmPrimitiveTypeKind.String);
AddProperty("isDeleted", EdmPrimitiveTypeKind.Boolean);
AddProperty("isProtected", EdmPrimitiveTypeKind.Boolean);
AddProperty("fileSize", EdmPrimitiveTypeKind.Int64);
AddProperty("fileVersion", EdmPrimitiveTypeKind.Int64);
AddProperty("lastModified", EdmPrimitiveTypeKind.DateTimeOffset);
AddProperty("lastModifiedBy", EdmPrimitiveTypeKind.String);
AddProperty("mimeType", EdmPrimitiveTypeKind.String);
AddProperty("slug", EdmPrimitiveTypeKind.String);
AddProperty("tags", EdmPrimitiveTypeKind.String);
AddProperty("type", EdmPrimitiveTypeKind.String);
var container = new EdmEntityContainer("Squidex", "Container");
container.AddEntitySet("AssetSet", entityType);
var model = new EdmModel();
model.AddElement(container);
model.AddElement(entityType);
return(model);
}
private static IEdmModel BuildEdmModel()
{
var entityType = new EdmEntityType("Squidex", "Asset");
void AddProperty(string name, EdmPrimitiveTypeKind type)
{
entityType.AddStructuralProperty(name.ToCamelCase(), type);
}
void AddPropertyReference(string name, IEdmTypeReference reference)
{
entityType.AddStructuralProperty(name.ToCamelCase(), reference);
}
var jsonType = new EdmComplexType("Squidex", "Json", null, false, true);
AddPropertyReference(nameof(IAssetEntity.Metadata), new EdmComplexTypeReference(jsonType, false));
AddProperty(nameof(IAssetEntity.Id), EdmPrimitiveTypeKind.String);
AddProperty(nameof(IAssetEntity.Created), EdmPrimitiveTypeKind.DateTimeOffset);
AddProperty(nameof(IAssetEntity.CreatedBy), EdmPrimitiveTypeKind.String);
AddProperty(nameof(IAssetEntity.FileHash), EdmPrimitiveTypeKind.String);
AddProperty(nameof(IAssetEntity.FileName), EdmPrimitiveTypeKind.String);
AddProperty(nameof(IAssetEntity.IsProtected), EdmPrimitiveTypeKind.Boolean);
AddProperty(nameof(IAssetEntity.FileSize), EdmPrimitiveTypeKind.Int64);
AddProperty(nameof(IAssetEntity.FileVersion), EdmPrimitiveTypeKind.Int64);
AddProperty(nameof(IAssetEntity.LastModified), EdmPrimitiveTypeKind.DateTimeOffset);
AddProperty(nameof(IAssetEntity.LastModifiedBy), EdmPrimitiveTypeKind.String);
AddProperty(nameof(IAssetEntity.MimeType), EdmPrimitiveTypeKind.String);
AddProperty(nameof(IAssetEntity.Slug), EdmPrimitiveTypeKind.String);
AddProperty(nameof(IAssetEntity.Tags), EdmPrimitiveTypeKind.String);
AddProperty(nameof(IAssetEntity.Type), EdmPrimitiveTypeKind.String);
AddProperty(nameof(IAssetEntity.Version), EdmPrimitiveTypeKind.Int64);
var container = new EdmEntityContainer("Squidex", "Container");
container.AddEntitySet("AssetSet", entityType);
var model = new EdmModel();
model.AddElement(container);
model.AddElement(entityType);
return(model);
}
public IEdmModel BuildModel(IEnumerable <TableData> tables)
{
var model = new EdmModel();
var container = new EdmEntityContainer("sitecore.com", "Visits");
model.AddElement(container);
var tableMap = new Dictionary <TableDataSchema, EdmEntityTypeWrapper>();
foreach (var table in tables)
{
var typeWrapper = AddTable(model, table);
container.AddEntitySet(table.Name, typeWrapper.Type);
tableMap.Add(table.Schema, typeWrapper);
}
foreach (var t in tableMap)
{
foreach (var reference in t.Key.RelatedTables)
{
if (reference.RelationType == RelationType.Child || reference.RelationType == RelationType.DimensionReference)
{
var source = t.Value;
var target = tableMap[reference.RelatedTable];
t.Value.Type.AddBidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = reference.RelatedTable.Name,
TargetMultiplicity = EdmMultiplicity.Many,
Target = target.Type
}, new EdmNavigationPropertyInfo()
{
Name = t.Key.Name,
TargetMultiplicity = reference.RelationType == RelationType.Child ? EdmMultiplicity.One : EdmMultiplicity.ZeroOrOne,
DependentProperties = reference.RelatedFields.Select(f => target.Properties[f]),
Target = source.Type
});
}
}
}
return(model);
}
public void ODataPathSegmentToTemplateHandler_Handles_EntitySet()
{
// Arrange
ODataPathSegmentToTemplateHandler handler = new ODataPathSegmentToTemplateHandler(null);
EdmEntityContainer entityContainer = new EdmEntityContainer("NS", "Default");
EdmEntityType customer = new EdmEntityType("NS", "Customer");
EdmEntitySet customers = entityContainer.AddEntitySet("Customers", customer);
EntitySetSegment segment = new EntitySetSegment(customers);
// Act
handler.Handle(segment);
// Assert
ODataSegmentTemplate segmentTemplate = Assert.Single(handler.Templates);
Assert.IsType <EntitySetSegmentTemplate>(segmentTemplate);
}
public Task <IEdmModel> GetModelAsync(InvocationContext context, CancellationToken cancellationToken)
{
var model = new EdmModel();
var ns = typeof(Person).Namespace;
var personType = new EdmEntityType(ns, "Person");
personType.AddKeys(personType.AddStructuralProperty("PersonId", EdmPrimitiveTypeKind.Int32));
model.AddElement(personType);
var customerType = new EdmEntityType(ns, "Customer");
customerType.AddKeys(customerType.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32));
model.AddElement(customerType);
var container = new EdmEntityContainer(ns, "DefaultContainer");
container.AddEntitySet("VipCustomers", personType);
model.AddElement(container);
return(Task.FromResult <IEdmModel>(model));
}
private void InitializeEdmModel()
{
this.model = new EdmModel();
this.customerEntityType = new EdmEntityType("NS", "Customer");
var customerIdProperty = this.customerEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
this.customerEntityType.AddKeys(customerIdProperty);
this.customerEntityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
this.model.AddElement(this.customerEntityType);
var entityContainer = new EdmEntityContainer("NS", "Container");
this.model.AddElement(entityContainer);
this.customerEntitySet = entityContainer.AddEntitySet("Customers", this.customerEntityType);
}
public DisablePrimitiveTypeConversionTests()
{
this.model = new EdmModel();
this.entityType = new EdmEntityType("FQ.NS", "EntityType", null, false, true);
this.entityType.AddStructuralProperty("String", EdmPrimitiveTypeKind.String);
this.entityType.AddStructuralProperty("Binary", EdmPrimitiveTypeKind.Binary);
this.model.AddElement(this.entityType);
var container = new EdmEntityContainer("FQ.NS", "Container");
this.model.AddElement(container);
container.AddEntitySet("Entities", this.entityType);
this.defaultSettings = new ODataMessageReaderSettings {
BaseUri = new Uri("http://serviceRoot/")
};
this.settingsWithConversionDisabled = this.defaultSettings.Clone();
this.settingsWithConversionDisabled.EnablePrimitiveTypeConversion = false;
}
public void MetadataDocumentReaderTestsForRepro()
{
List <MetadataReaderTestDescriptor> testCases = new List <MetadataReaderTestDescriptor>();
EdmModel model = new EdmModel();
var addressType = new EdmComplexType("TestModel", "Address");
addressType.AddStructuralProperty("Zip", EdmPrimitiveTypeKind.Int32, isNullable: false);
addressType.AddStructuralProperty("Image", EdmPrimitiveTypeKind.Stream, isNullable: false);
model.AddElement(addressType);
var personType = new EdmEntityType("TestModel", "Person");
personType.AddKeys(personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, isNullable: false));
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String, isNullable: true);
personType.AddStructuralProperty("Photo", EdmPrimitiveTypeKind.Stream, isNullable: false);
personType.AddStructuralProperty("Address", addressType.ToTypeReference());
personType.AddStructuralProperty("Photos", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetStream(isNullable: false)));
model.AddElement(personType);
var container = new EdmEntityContainer("TestModel", "DefaultContainer");
container.AddEntitySet("Person", personType);
model.AddElement(container);
//personType.EntityPropertyMapping("Name", SyndicationItemProperty.AuthorName);
// TODO: Both the mappings below fail differently. Once it is fixed add these tests to error tests in MetadataDocumentReaderErrorTests.cs file.
// This fails since annotations don't match which is very likely due to the product silently dropping the annotation mapped to stream.
// Where as the mapping on property on ComplexType fails with the right error message.
// personType.EntityPropertyMapping("Photo", SyndicationItemProperty.Summary);
// personType.EntityPropertyMapping("Address/Image", SyndicationItemProperty.Title);
// The below fails with yet another error message saying basically that mapping is different.
// personType.EntityPropertyMapping("Photos", SyndicationItemProperty.AuthorEmail);
testCases.Add(this.CreateMetadataDescriptor(model));
this.CombinatorialEngineProvider.RunCombinations(
testCases,
this.ReaderTestConfigurationProvider.DefaultFormatConfigurations.Where(tc => tc.Synchronous && !tc.IsRequest),
(testDescriptor, testConfiguration) => testDescriptor.RunTest(testConfiguration));
}
public Task<IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var model = new EdmModel();
var entityType = new EdmEntityType(
"TestNamespace", "TestName");
var entityContainer = new EdmEntityContainer(
"TestNamespace", "Entities");
entityContainer.AddEntitySet("TestEntitySet", entityType);
model.AddElement(entityType);
model.AddElement(entityContainer);
return Task.FromResult<IEdmModel>(model);
}
