internal static Uri GenerateActionLink(EntityInstanceContext entityContext, ActionConfiguration action)
{
// the entity type the action is bound to.
EntityTypeConfiguration actionEntityType = action.BindingParameter.TypeConfiguration as EntityTypeConfiguration;
Contract.Assert(actionEntityType != null, "we have already verified that binding paramter type is entity");
Dictionary<string, object> routeValues = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
routeValues.Add(LinkGenerationConstants.Controller, entityContext.EntitySet.Name);
routeValues.Add(LinkGenerationConstants.BoundId, ConventionsHelpers.GetEntityKeyValue(entityContext, actionEntityType));
routeValues.Add(LinkGenerationConstants.ODataAction, action.Name);
string routeName;
// generate link without cast if the entityset type matches the entity type the action is bound to.
if (entityContext.EntitySet.ElementType.IsOrInheritsFrom(entityContext.EdmModel.FindDeclaredType(actionEntityType.FullName)))
{
routeName = ODataRouteNames.InvokeBoundAction;
}
else
{
routeName = ODataRouteNames.InvokeBoundActionWithCast;
routeValues.Add(LinkGenerationConstants.Entitytype, entityContext.EntityType.FullName());
}
string actionLink = entityContext.UrlHelper.Link(routeName, routeValues);
if (actionLink == null)
{
return null;
}
else
{
return new Uri(actionLink);
}
}
internal static Uri GenerateActionLink(EntityInstanceContext entityContext, ActionConfiguration action)
{
// the entity type the action is bound to.
EntityTypeConfiguration actionEntityType = action.BindingParameter.TypeConfiguration as EntityTypeConfiguration;
Contract.Assert(actionEntityType != null, "we have already verified that binding paramter type is entity");
List<ODataPathSegment> actionPathSegments = new List<ODataPathSegment>();
actionPathSegments.Add(new EntitySetPathSegment(entityContext.EntitySet));
actionPathSegments.Add(new KeyValuePathSegment(ConventionsHelpers.GetEntityKeyValue(entityContext)));
// generate link with cast if the entityset type doesn't match the entity type the action is bound to.
if (!entityContext.EntitySet.ElementType.IsOrInheritsFrom(entityContext.EdmModel.FindDeclaredType(actionEntityType.FullName)))
{
actionPathSegments.Add(new CastPathSegment(entityContext.EntityType));
}
actionPathSegments.Add(new ActionPathSegment(action.Name));
string actionLink = entityContext.Url.ODataLink(actionPathSegments);
if (actionLink == null)
{
return null;
}
return new Uri(actionLink);
}
internal bool Override( IActivityMonitor monitor, IReadOnlyList<string> fullPath, ActionConfiguration a )
{
var e = fullPath.GetEnumerator();
if( !e.MoveNext() ) throw new ArgumentException( "Must not be empty.", "fullPath" );
if( e.Current != _action.Name ) throw new ArgumentException( "Must start with the action name.", "fullPath" );
if( !e.MoveNext() )
{
_action = a;
_isCloned = false;
monitor.SendLine( LogLevel.Info, string.Format( "Action '{0}' has been overridden.", a.Name ), null );
return true;
}
ActionCompositeConfiguration parent;
int idx = FindInComposite( e, out parent );
if( idx >= 0 )
{
Debug.Assert( _action is ActionCompositeConfiguration, "It is a composite." );
Debug.Assert( _action.IsCloneable, "A composite is cloneable." );
if( !_isCloned )
{
_action = ((ActionCompositeConfiguration)_action).CloneComposite( true );
monitor.SendLine( LogLevel.Info, string.Format( "Action '{0}' has been cloned in order to override an inner action.", string.Join( "/", fullPath ) ), null );
_isCloned = true;
idx = FindInComposite( e, out parent );
}
Debug.Assert( parent.Children[idx].Name == fullPath.Last() );
parent.Override( idx, a );
monitor.SendLine( LogLevel.Info, string.Format( "Inner action '{0}' has been overridden.", string.Join( "/", fullPath ) ), null );
return true;
}
monitor.SendLine( LogLevel.Error, string.Format( "Action '{0}' not found. Unable to override it.", string.Join( "/", fullPath ) ), null );
return false;
}
public FileEventListener Create(ISolutionProject project, ActionConfiguration actionConfiguration)
{
var fileChangeSubscriber = new FileChangeSubscriber(this.fileChangeService);
var fileMonitor = new FileMonitor(this.solutionFilesService, this.globMatcher, fileChangeSubscriber, this.outputService);
var eventListener = new FileEventListener(fileMonitor, this.onChangeTaskDispatcher, this.actionFactory, fileChangeSubscriber);
eventListener.Initialize(project, actionConfiguration);
return eventListener;
}
public void CanRemoveProcedureByName()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = new ActionConfiguration(builder, "Format");
bool removed = builder.RemoveProcedure("Format");
// Assert
Assert.Equal(0, builder.Procedures.Count());
}
public void CanCreateActionWithPrimitiveCollectionReturnType()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = new ActionConfiguration(builder, "CreateMessages");
action.ReturnsCollection<string>();
// Assert
Assert.NotNull(action.ReturnType);
Assert.Equal("Collection(Edm.String)", action.ReturnType.FullName);
}
public void CanBuildBoundProcedureCacheForIEdmModel()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration<Customer> customer = builder.EntitySet<Customer>("Customers").EntityType;
customer.HasKey(c => c.ID);
customer.Property(c => c.Name);
customer.ComplexProperty(c => c.Address);
EntityTypeConfiguration<Movie> movie = builder.EntitySet<Movie>("Movies").EntityType;
movie.HasKey(m => m.ID);
movie.HasKey(m => m.Name);
EntityTypeConfiguration<Blockbuster> blockBuster = builder.Entity<Blockbuster>().DerivesFrom<Movie>();
IEntityTypeConfiguration movieConfiguration = builder.StructuralTypes.OfType<IEntityTypeConfiguration>().Single(t => t.Name == "Movie");
// build actions that are bindable to a single entity
customer.Action("InCache1_CustomerAction");
customer.Action("InCache2_CustomerAction");
movie.Action("InCache3_MovieAction");
ActionConfiguration incache4_MovieAction = new ActionConfiguration(builder, "InCache4_MovieAction");
incache4_MovieAction.SetBindingParameter("bindingParameter", movieConfiguration, true);
blockBuster.Action("InCache5_BlockbusterAction");
// build actions that are either: bindable to a collection of entities, have no parameter, have only complex parameter
customer.Collection.Action("NotInCache1_CustomersAction");
movie.Collection.Action("NotInCache2_MoviesAction");
ActionConfiguration notInCache3_NoParameters = new ActionConfiguration(builder, "NotInCache3_NoParameters");
ActionConfiguration notInCache4_AddressParameter = new ActionConfiguration(builder, "NotInCache4_AddressParameter");
notInCache4_AddressParameter.Parameter<Address>("address");
IEdmModel model = builder.GetEdmModel();
IEdmEntityType customerType = model.SchemaElements.OfType<IEdmEntityType>().Single(e => e.Name == "Customer");
IEdmEntityType movieType = model.SchemaElements.OfType<IEdmEntityType>().Single(e => e.Name == "Movie");
IEdmEntityType blockBusterType = model.SchemaElements.OfType<IEdmEntityType>().Single(e => e.Name == "Blockbuster");
// Act
BindableProcedureFinder annotation = new BindableProcedureFinder(model);
IEdmFunctionImport[] movieActions = annotation.FindProcedures(movieType).ToArray();
IEdmFunctionImport[] customerActions = annotation.FindProcedures(customerType).ToArray();
IEdmFunctionImport[] blockBusterActions = annotation.FindProcedures(blockBusterType).ToArray();
// Assert
Assert.Equal(2, customerActions.Length);
Assert.NotNull(customerActions.SingleOrDefault(a => a.Name == "InCache1_CustomerAction"));
Assert.NotNull(customerActions.SingleOrDefault(a => a.Name == "InCache2_CustomerAction"));
Assert.Equal(2, movieActions.Length);
Assert.NotNull(movieActions.SingleOrDefault(a => a.Name == "InCache3_MovieAction"));
Assert.NotNull(movieActions.SingleOrDefault(a => a.Name == "InCache4_MovieAction"));
Assert.Equal(3, blockBusterActions.Length);
Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache3_MovieAction"));
Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache4_MovieAction"));
Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache5_BlockbusterAction"));
}
public void CanRemoveProcedure()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = new ActionConfiguration(builder, "Format");
ProcedureConfiguration procedure = builder.Procedures.SingleOrDefault();
bool removed = builder.RemoveProcedure(procedure);
// Assert
Assert.True(removed);
Assert.Equal(0, builder.Procedures.Count());
}
public void RemoveProcedureByNameThrowsWhenAmbiguous()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action1 = new ActionConfiguration(builder, "Format");
ActionConfiguration action2 = new ActionConfiguration(builder, "Format");
action2.Parameter<int>("SegmentSize");
Assert.Throws<InvalidOperationException>(() =>
{
builder.RemoveProcedure("Format");
});
}
public void AttemptToRemoveNonExistantEntityReturnsFalse()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
ODataModelBuilder builder2 = new ODataModelBuilder();
ProcedureConfiguration toRemove = new ActionConfiguration(builder2, "ToRemove");
// Act
bool removedByName = builder.RemoveProcedure("ToRemove");
bool removed = builder.RemoveProcedure(toRemove);
//Assert
Assert.False(removedByName);
Assert.False(removed);
}
public void Apply_FollowsConventions()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = new ActionConfiguration(builder, "IgnoreAction");
Mock<IEdmTypeConfiguration> mockBindingParameterType = new Mock<IEdmTypeConfiguration>();
mockBindingParameterType.Setup(o => o.Kind).Returns(EdmTypeKind.Entity);
action.SetBindingParameter("IgnoreParameter", mockBindingParameterType.Object, alwaysBindable: false);
ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention();
// Act
convention.Apply(action, builder);
// Assert
Assert.True(action.FollowsConventions);
}
public void CanCreateActionWithNoArguments()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
builder.Namespace = "MyNamespace";
builder.ContainerName = "MyContainer";
ActionConfiguration action = new ActionConfiguration(builder, "Format");
// Assert
Assert.Equal("Format", action.Name);
Assert.Equal(ProcedureKind.Action, action.Kind);
Assert.NotNull(action.Parameters);
Assert.Empty(action.Parameters);
Assert.Null(action.ReturnType);
Assert.True(action.IsSideEffecting);
Assert.False(action.IsComposable);
Assert.False(action.IsBindable);
Assert.Equal("MyContainer.Format", action.ContainerQualifiedName);
Assert.Equal("MyContainer.Format", action.FullName);
Assert.Equal("MyNamespace.MyContainer.Format", action.FullyQualifiedName);
Assert.NotNull(builder.Procedures);
Assert.Equal(1, builder.Procedures.Count());
}
private static IEdmExpression GetEdmEntitySetExpression(Dictionary<string, EdmEntitySet> entitySets, ActionConfiguration action)
{
if (action.EntitySet != null)
{
if (entitySets.ContainsKey(action.EntitySet.Name))
{
EdmEntitySet entitySet = entitySets[action.EntitySet.Name];
return new EdmEntitySetReferenceExpression(entitySet);
}
else
{
throw Error.InvalidOperation(SRResources.EntitySetNotFoundForName, action.EntitySet.Name);
}
}
return null;
}
public void ActionLink_PreservesFollowsConventions(bool value)
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock<ODataModelBuilder>();
ActionConfiguration configuration = new ActionConfiguration(builder, "IgnoreAction");
Mock<IEdmTypeConfiguration> bindingParameterTypeMock = new Mock<IEdmTypeConfiguration>();
bindingParameterTypeMock.Setup(o => o.Kind).Returns(EdmTypeKind.Entity);
Type entityType = typeof(object);
bindingParameterTypeMock.Setup(o => o.ClrType).Returns(entityType);
configuration.SetBindingParameter("IgnoreParameter", bindingParameterTypeMock.Object,
alwaysBindable: false);
configuration.HasActionLink((a) => { throw new NotImplementedException(); }, followsConventions: value);
builder.AddProcedure(configuration);
builder.AddEntityType(entityType);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
var action = Assert.Single(model.SchemaElements.OfType<IEdmAction>());
ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(action);
Assert.NotNull(actionLinkBuilder);
Assert.Equal(value, actionLinkBuilder.FollowsConventions);
}
protected void RegisterProduct(ODataConventionModelBuilder builder)
{
builder.EntitySet <ProductDto>("Product");
var product = builder.EntityType <ProductDto>();
product.Count().Filter().OrderBy().Page();
builder.ComplexType <ProductCategoryDto>();
builder.ComplexType <ProductManufacturerDto>();
builder.ComplexType <ProductPictureDto>();
builder.ComplexType <ProductSpecificationAttributeDto>();
builder.ComplexType <ProductTierPriceDto>();
builder.ComplexType <ProductWarehouseInventoryDto>();
builder.ComplexType <ProductAttributeMappingDto>();
builder.ComplexType <ProductAttributeValueDto>();
builder.ComplexType <ProductAttributeCombinationDto>();
//update stock for product
ActionConfiguration updateStock = product.Action("UpdateStock");
updateStock.Parameter <string>("WarehouseId");
updateStock.Parameter <int>("Stock").Required();
updateStock.Returns <bool>();
//insert/update/delete category
#region Product category
ActionConfiguration createCategory = product.Action("CreateProductCategory");
createCategory.Parameter <string>(nameof(ProductCategoryDto.CategoryId)).Required();
createCategory.Parameter <bool>(nameof(ProductCategoryDto.IsFeaturedProduct));
createCategory.Returns <bool>();
ActionConfiguration updateCategory = product.Action("UpdateProductCategory");
updateCategory.Parameter <string>(nameof(ProductCategoryDto.CategoryId)).Required();
updateCategory.Parameter <bool>(nameof(ProductCategoryDto.IsFeaturedProduct));
updateCategory.Returns <bool>();
ActionConfiguration deleteCategory = product.Action("DeleteProductCategory");
deleteCategory.Parameter <string>(nameof(ProductCategoryDto.CategoryId)).Required();
deleteCategory.Returns <bool>();
#endregion
//insert/update/delete manufacturer
#region Product manufacturer
ActionConfiguration createManufacturer = product.Action("CreateProductManufacturer");
createManufacturer.Parameter <string>(nameof(ProductManufacturerDto.ManufacturerId)).Required();
createManufacturer.Parameter <bool>(nameof(ProductManufacturerDto.IsFeaturedProduct));
createManufacturer.Returns <bool>();
ActionConfiguration updateManufacturer = product.Action("UpdateProductManufacturer");
updateManufacturer.Parameter <string>(nameof(ProductManufacturerDto.ManufacturerId)).Required();
updateManufacturer.Parameter <bool>(nameof(ProductManufacturerDto.IsFeaturedProduct));
updateManufacturer.Returns <bool>();
ActionConfiguration deleteManufacturer = product.Action("DeleteProductManufacturer");
deleteManufacturer.Parameter <string>(nameof(ProductManufacturerDto.ManufacturerId)).Required();
deleteManufacturer.Returns <bool>();
#endregion
//insert/update/delete picture
#region Product picture
ActionConfiguration createPicture = product.Action("CreateProductPicture");
createPicture.Parameter <string>(nameof(ProductPictureDto.PictureId)).Required();
createPicture.Parameter <string>(nameof(ProductPictureDto.MimeType)).Required();
createPicture.Parameter <string>(nameof(ProductPictureDto.SeoFilename)).Required();
createPicture.Parameter <string>(nameof(ProductPictureDto.AltAttribute)).Required();
createPicture.Parameter <int>(nameof(ProductPictureDto.DisplayOrder)).Required();
createPicture.Parameter <string>(nameof(ProductPictureDto.TitleAttribute)).Required();
createPicture.Returns <bool>();
ActionConfiguration updatePicture = product.Action("UpdateProductPicture");
updatePicture.Parameter <string>(nameof(ProductPictureDto.PictureId)).Required();
updatePicture.Parameter <string>(nameof(ProductPictureDto.MimeType)).Required();
updatePicture.Parameter <string>(nameof(ProductPictureDto.SeoFilename)).Required();
updatePicture.Parameter <string>(nameof(ProductPictureDto.AltAttribute)).Required();
updatePicture.Parameter <int>(nameof(ProductPictureDto.DisplayOrder)).Required();
updatePicture.Parameter <string>(nameof(ProductPictureDto.TitleAttribute)).Required();
updatePicture.Returns <bool>();
ActionConfiguration deletePicture = product.Action("DeleteProductPicture");
deletePicture.Parameter <string>(nameof(ProductPictureDto.PictureId)).Required();
deletePicture.Returns <bool>();
#endregion
#region Product specification
ActionConfiguration createSpecification = product.Action("CreateProductSpecification");
createSpecification.Parameter <string>(nameof(ProductSpecificationAttributeDto.Id));
createSpecification.Parameter <int>(nameof(ProductSpecificationAttributeDto.DisplayOrder));
createSpecification.Parameter <string>(nameof(ProductSpecificationAttributeDto.CustomValue));
createSpecification.Parameter <SpecificationAttributeType>(nameof(ProductSpecificationAttributeDto.AttributeType)).Required();
createSpecification.Parameter <bool>(nameof(ProductSpecificationAttributeDto.AllowFiltering));
createSpecification.Parameter <string>(nameof(ProductSpecificationAttributeDto.SpecificationAttributeId));
createSpecification.Parameter <bool>(nameof(ProductSpecificationAttributeDto.ShowOnProductPage));
createSpecification.Parameter <string>(nameof(ProductSpecificationAttributeDto.SpecificationAttributeOptionId));
createSpecification.Returns <bool>();
ActionConfiguration updateSpecification = product.Action("UpdateProductSpecification");
updateSpecification.Parameter <string>(nameof(ProductSpecificationAttributeDto.Id)).Required();
updateSpecification.Parameter <int>(nameof(ProductSpecificationAttributeDto.DisplayOrder));
updateSpecification.Parameter <string>(nameof(ProductSpecificationAttributeDto.CustomValue));
updateSpecification.Parameter <SpecificationAttributeType>(nameof(ProductSpecificationAttributeDto.AttributeType)).Required();
updateSpecification.Parameter <bool>(nameof(ProductSpecificationAttributeDto.AllowFiltering));
updateSpecification.Parameter <string>(nameof(ProductSpecificationAttributeDto.SpecificationAttributeId)).Required();
updateSpecification.Parameter <bool>(nameof(ProductSpecificationAttributeDto.ShowOnProductPage));
updateSpecification.Parameter <string>(nameof(ProductSpecificationAttributeDto.SpecificationAttributeOptionId));
updateSpecification.Returns <bool>();
ActionConfiguration deleteSpecification = product.Action("DeleteProductSpecification");
deleteSpecification.Parameter <string>(nameof(ProductSpecificationAttributeDto.Id)).Required();
deleteSpecification.Returns <bool>();
#endregion
#region Product attribute mapping
ActionConfiguration createProductAttributeMapping = product.Action("CreateProductAttributeMapping");
createProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.Id));
createProductAttributeMapping.Parameter <int>(nameof(ProductAttributeMappingDto.DisplayOrder));
createProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.ConditionAttributeXml));
createProductAttributeMapping.Parameter <AttributeControlType>(nameof(ProductAttributeMappingDto.AttributeControlType)).Required();
createProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.DefaultValue));
createProductAttributeMapping.Parameter <bool>(nameof(ProductAttributeMappingDto.IsRequired));
createProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.TextPrompt));
createProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.ValidationFileAllowedExtensions));
createProductAttributeMapping.Parameter <int?>(nameof(ProductAttributeMappingDto.ValidationFileMaximumSize));
createProductAttributeMapping.Parameter <int?>(nameof(ProductAttributeMappingDto.ValidationMaxLength));
createProductAttributeMapping.Parameter <int?>(nameof(ProductAttributeMappingDto.ValidationMinLength));
createProductAttributeMapping.Parameter <List <ProductAttributeValueDto> >(nameof(ProductAttributeMappingDto.ProductAttributeValues));
createProductAttributeMapping.Returns <ProductAttributeMappingDto>();
ActionConfiguration updateProductAttributeMapping = product.Action("UpdateProductAttributeMapping");
updateProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.Id)).Required();
updateProductAttributeMapping.Parameter <int>(nameof(ProductAttributeMappingDto.DisplayOrder));
updateProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.ConditionAttributeXml));
updateProductAttributeMapping.Parameter <AttributeControlType>(nameof(ProductAttributeMappingDto.AttributeControlType)).Required();
updateProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.DefaultValue));
updateProductAttributeMapping.Parameter <bool>(nameof(ProductAttributeMappingDto.IsRequired));
updateProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.TextPrompt));
updateProductAttributeMapping.Parameter <string>(nameof(ProductAttributeMappingDto.ValidationFileAllowedExtensions));
updateProductAttributeMapping.Parameter <int?>(nameof(ProductAttributeMappingDto.ValidationFileMaximumSize));
updateProductAttributeMapping.Parameter <int?>(nameof(ProductAttributeMappingDto.ValidationMaxLength));
updateProductAttributeMapping.Parameter <int?>(nameof(ProductAttributeMappingDto.ValidationMinLength));
updateProductAttributeMapping.Parameter <List <ProductAttributeValueDto> >(nameof(ProductAttributeMappingDto.ProductAttributeValues));
updateProductAttributeMapping.Returns <ProductAttributeMappingDto>();
ActionConfiguration deleteProductAttributeMapping = product.Action("DeleteProductAttributeMapping");
deleteProductAttributeMapping.Parameter <string>(nameof(ProductSpecificationAttributeDto.Id)).Required();
deleteProductAttributeMapping.Returns <bool>();
#endregion
//insert/update/delete tier price
#region Product tierprice
ActionConfiguration createTierPrice = product.Action("CreateProductTierPrice");
createTierPrice.Parameter <int>(nameof(ProductTierPriceDto.Quantity));
createTierPrice.Parameter <decimal>(nameof(ProductTierPriceDto.Price));
createTierPrice.Parameter <string>(nameof(ProductTierPriceDto.StoreId));
createTierPrice.Parameter <string>(nameof(ProductTierPriceDto.CustomerRoleId));
createTierPrice.Parameter <DateTime?>(nameof(ProductTierPriceDto.StartDateTimeUtc));
createTierPrice.Parameter <DateTime?>(nameof(ProductTierPriceDto.EndDateTimeUtc));
createTierPrice.Returns <bool>();
ActionConfiguration updateTierPrice = product.Action("UpdateProductTierPrice");
updateTierPrice.Parameter <string>(nameof(ProductTierPriceDto.Id)).Required();
updateTierPrice.Parameter <int>(nameof(ProductTierPriceDto.Quantity));
updateTierPrice.Parameter <decimal>(nameof(ProductTierPriceDto.Price));
updateTierPrice.Parameter <string>(nameof(ProductTierPriceDto.StoreId));
updateTierPrice.Parameter <string>(nameof(ProductTierPriceDto.CustomerRoleId));
updateTierPrice.Parameter <DateTime?>(nameof(ProductTierPriceDto.StartDateTimeUtc));
updateTierPrice.Parameter <DateTime?>(nameof(ProductTierPriceDto.EndDateTimeUtc));
updateTierPrice.Returns <bool>();
ActionConfiguration deleteTierPrice = product.Action("DeleteProductTierPrice");
deleteTierPrice.Parameter <string>(nameof(ProductTierPriceDto.Id)).Required();
deleteTierPrice.Returns <bool>();
#endregion
}
bool IProtoRouteConfigurationContext.DeclareAction( ActionConfiguration a, bool overridden )
{
if( a == null ) throw new ArgumentNullException();
ProtoDeclaredAction existsHere;
if( _declaredActions.TryGetValue( a.Name, out existsHere ) )
{
if( overridden )
{
_declaredActions[a.Name] = new ProtoDeclaredAction( a );
Monitor.SendLine( LogLevel.Info, string.Format( "Action '{0}' is overridden", a.Name ), null );
return true;
}
Monitor.SendLine( LogLevel.Error, string.Format( "Action '{0}' is already declared. Use Override to alter it or use another name.", a.Name ), null );
return false;
}
_declaredActions.Add( a.Name, new ProtoDeclaredAction( a ) );
return true;
}
public static string GetStringReplacedQuery(HttpRequest request, RouteConfiguration route, ActionConfiguration action, object id, string json = null)
{
string sqlQuery = GetStringReplacedQuery(request, route, action, json);
sqlQuery = sqlQuery.Replace(ID_SYMBOL, id.ToString());
return(sqlQuery);
}
public static string GetStringReplacedQuery(HttpRequest request, RouteConfiguration route, ActionConfiguration action, string json = null)
{
if (String.IsNullOrEmpty(action.Query))
{
throw new Exception("The action query is required.");
}
string sqlQuery = action.Query;
sqlQuery = sqlQuery.Replace(SCHEMA_SYMBOL, route.Schema);
sqlQuery = sqlQuery.Replace(TABLE_SYMBOL, route.Table);
sqlQuery = sqlQuery.Replace(SCHEMA_TABLE_SYMBOL, GetSchemaTableName(route));
// extract OData query information
List <string> odataSelectColumns = new List <string>();
//string odataTopValue = null;
foreach (KeyValuePair <String, StringValues> query in request.Query)
{
if (query.Key.ToLower() == "$select")
{
odataSelectColumns = query.Value.ToString().Split(',').ToList();
}
//else if (query.Key.ToLower() == "$top")
//{
// odataTopValue = query.Value.ToString();
//}
}
List <string> selectString = new List <string>();
if (route.Columns.Any())
{
if (odataSelectColumns.Count > 0)
{
foreach (string odataSelectColumn in odataSelectColumns)
{
if (route.Columns.Find(cc => cc.ColumnName == odataSelectColumn) != null)
{
selectString.Add(odataSelectColumn);
}
else
{
throw new Exception("The OData $SELECT column '" + odataSelectColumn + "' is not a configured property for route '" + route.Name + "'.");
}
}
}
else
{
foreach (ColumnConfiguration column in route.Columns)
{
selectString.Add(column.ColumnName);
}
}
}
else
{
if (odataSelectColumns.Count > 0)
{
selectString = odataSelectColumns;
}
else
{
selectString.Add("*");
}
}
sqlQuery = sqlQuery.Replace(COLUMN_NAMES_SYMBOL, String.Join(",", selectString));
//if (odataTopValue != null)
//{
// int indexOfFirstSelect = sqlQuery.ToLower().IndexOf("select");
// sqlQuery = sqlQuery.Insert(indexOfFirstSelect + 6, " TOP " + odataTopValue);
//}
sqlQuery = sqlQuery.Replace(PRIMARY_KEY_COLUMN_SYMBOL, route.PrimaryKeyColumn);
if (!String.IsNullOrEmpty(json))
{
sqlQuery = ReplaceBodyColumnNamesAndValues(sqlQuery, json);
}
return(sqlQuery);
}
public static ActionConfiguration ActionReturnsCollectionFromEntitySet <TElementEntityType>(ODataModelBuilder builder, ActionConfiguration action, string entitySetName) where TElementEntityType : class
{
Type clrCollectionType = typeof(IEnumerable <TElementEntityType>);
action.NavigationSource = CreateOrReuseEntitySet <TElementEntityType>(builder, entitySetName);
IEdmTypeConfiguration elementType = builder.GetTypeConfigurationOrNull(typeof(TElementEntityType));
action.ReturnType = new CollectionTypeConfiguration(elementType, clrCollectionType);
return(action);
}
protected void RegisterCustomers(ODataConventionModelBuilder builder)
{
#region Customer
builder.EntitySet <CustomerDto>("Customer");
var customer = builder.EntityType <CustomerDto>();
builder.ComplexType <AddressDto>();
ActionConfiguration addAddress = customer.Action("AddAddress");
addAddress.Parameter <string>(nameof(AddressDto.Id)).Required();
addAddress.Parameter <string>(nameof(AddressDto.City));
addAddress.Parameter <string>(nameof(AddressDto.Email));
addAddress.Parameter <string>(nameof(AddressDto.Company));
addAddress.Parameter <string>(nameof(AddressDto.Address1));
addAddress.Parameter <string>(nameof(AddressDto.Address2));
addAddress.Parameter <string>(nameof(AddressDto.LastName));
addAddress.Parameter <string>(nameof(AddressDto.CountryId));
addAddress.Parameter <string>(nameof(AddressDto.FaxNumber));
addAddress.Parameter <string>(nameof(AddressDto.FirstName));
addAddress.Parameter <string>(nameof(AddressDto.VatNumber));
addAddress.Parameter <string>(nameof(AddressDto.PhoneNumber));
addAddress.Parameter <string>(nameof(AddressDto.CustomAttributes));
addAddress.Parameter <DateTimeOffset>(nameof(AddressDto.CreatedOnUtc));
addAddress.Parameter <string>(nameof(AddressDto.ZipPostalCode));
addAddress.Parameter <string>(nameof(AddressDto.StateProvinceId));
addAddress.Returns <AddressDto>();
ActionConfiguration updateAddress = customer.Action("UpdateAddress");
updateAddress.Parameter <string>(nameof(AddressDto.Id)).Required();
updateAddress.Parameter <string>(nameof(AddressDto.City));
updateAddress.Parameter <string>(nameof(AddressDto.Email));
updateAddress.Parameter <string>(nameof(AddressDto.Company));
updateAddress.Parameter <string>(nameof(AddressDto.Address1));
updateAddress.Parameter <string>(nameof(AddressDto.Address2));
updateAddress.Parameter <string>(nameof(AddressDto.LastName));
updateAddress.Parameter <string>(nameof(AddressDto.CountryId));
updateAddress.Parameter <string>(nameof(AddressDto.FaxNumber));
updateAddress.Parameter <string>(nameof(AddressDto.FirstName));
updateAddress.Parameter <string>(nameof(AddressDto.VatNumber));
updateAddress.Parameter <string>(nameof(AddressDto.PhoneNumber));
updateAddress.Parameter <string>(nameof(AddressDto.CustomAttributes));
updateAddress.Parameter <DateTimeOffset>(nameof(AddressDto.CreatedOnUtc));
updateAddress.Parameter <string>(nameof(AddressDto.ZipPostalCode));
updateAddress.Parameter <string>(nameof(AddressDto.StateProvinceId));
updateAddress.Returns <AddressDto>();
ActionConfiguration deleteAddress = customer.Action("DeleteAddress");
deleteAddress.Parameter <string>("addressId");
deleteAddress.Returns <bool>();
ActionConfiguration changePassword = customer.Action("SetPassword");
changePassword.Parameter <string>("password");
changePassword.Returns <bool>();
#endregion
#region Customer Role model
builder.EntitySet <CustomerRoleDto>("CustomerRole");
builder.EntityType <CustomerRoleDto>().Count().Filter().OrderBy().Page();
#endregion
#region Vendors
builder.EntitySet <VendorDto>("Vendor");
builder.EntityType <VendorDto>().Count().Filter().OrderBy().Page();
#endregion
}
public static IEdmModel GetModel(IAssemblyProvider assemblyProvider)
{
if (_model != null)
{
return(_model);
}
ODataConventionModelBuilder builder = new ODataConventionModelBuilder(assemblyProvider);
builder.EntitySet <RoutingCustomer>("RoutingCustomers");
builder.EntitySet <Product>("Products");
builder.EntitySet <SalesPerson>("SalesPeople");
builder.EntitySet <EmailAddress>("EmailAddresses");
builder.EntitySet <üCategory>("üCategories");
builder.EntitySet <EnumCustomer>("EnumCustomers");
builder.Singleton <RoutingCustomer>("VipCustomer");
builder.Singleton <Product>("MyProduct");
builder.EntitySet <DateTimeOffsetKeyCustomer>("DateTimeOffsetKeyCustomers");
builder.EntitySet <Destination>("Destinations");
builder.ComplexType <Dog>();
builder.ComplexType <Cat>();
builder.EntityType <SpecialProduct>();
builder.ComplexType <UsAddress>();
ActionConfiguration getRoutingCustomerById = builder.Action("GetRoutingCustomerById");
getRoutingCustomerById.Parameter <int>("RoutingCustomerId");
getRoutingCustomerById.ReturnsFromEntitySet <RoutingCustomer>("RoutingCustomers");
ActionConfiguration getSalesPersonById = builder.Action("GetSalesPersonById");
getSalesPersonById.Parameter <int>("salesPersonId");
getSalesPersonById.ReturnsFromEntitySet <SalesPerson>("SalesPeople");
ActionConfiguration getAllVIPs = builder.Action("GetAllVIPs");
ActionReturnsCollectionFromEntitySet <VIP>(builder, getAllVIPs, "RoutingCustomers");
builder.EntityType <RoutingCustomer>().ComplexProperty <Address>(c => c.Address);
builder.EntityType <RoutingCustomer>().Action("GetRelatedRoutingCustomers").ReturnsCollectionFromEntitySet <RoutingCustomer>("RoutingCustomers");
ActionConfiguration getBestRelatedRoutingCustomer = builder.EntityType <RoutingCustomer>().Action("GetBestRelatedRoutingCustomer");
ActionReturnsFromEntitySet <VIP>(builder, getBestRelatedRoutingCustomer, "RoutingCustomers");
ActionConfiguration getVIPS = builder.EntityType <RoutingCustomer>().Collection.Action("GetVIPs");
ActionReturnsCollectionFromEntitySet <VIP>(builder, getVIPS, "RoutingCustomers");
builder.EntityType <RoutingCustomer>().Collection.Action("GetProducts").ReturnsCollectionFromEntitySet <Product>("Products");
builder.EntityType <VIP>().Action("GetSalesPerson").ReturnsFromEntitySet <SalesPerson>("SalesPeople");
builder.EntityType <VIP>().Collection.Action("GetSalesPeople").ReturnsCollectionFromEntitySet <SalesPerson>("SalesPeople");
ActionConfiguration getMostProfitable = builder.EntityType <VIP>().Collection.Action("GetMostProfitable");
ActionReturnsFromEntitySet <VIP>(builder, getMostProfitable, "RoutingCustomers");
ActionConfiguration getVIPRoutingCustomers = builder.EntityType <SalesPerson>().Action("GetVIPRoutingCustomers");
ActionReturnsCollectionFromEntitySet <VIP>(builder, getVIPRoutingCustomers, "RoutingCustomers");
ActionConfiguration getVIPRoutingCustomersOnCollection = builder.EntityType <SalesPerson>().Collection.Action("GetVIPRoutingCustomers");
ActionReturnsCollectionFromEntitySet <VIP>(builder, getVIPRoutingCustomersOnCollection, "RoutingCustomers");
builder.EntityType <VIP>().HasRequired(v => v.RelationshipManager);
builder.EntityType <ImportantProduct>().HasRequired(ip => ip.LeadSalesPerson);
// function bound to an entity
FunctionConfiguration topProductId = builder.EntityType <Product>().Function("TopProductId");
topProductId.Returns <int>();
FunctionConfiguration topProductIdByCity = builder.EntityType <Product>().Function("TopProductIdByCity");
topProductIdByCity.Parameter <string>("city");
topProductIdByCity.Returns <string>();
FunctionConfiguration topProductIdByCityAndModel = builder.EntityType <Product>().Function("TopProductIdByCityAndModel");
topProductIdByCityAndModel.Parameter <string>("city");
topProductIdByCityAndModel.Parameter <int>("model");
topProductIdByCityAndModel.Returns <string>();
// function bound to a collection of entities
FunctionConfiguration topProductOfAll = builder.EntityType <Product>().Collection.Function("TopProductOfAll");
topProductOfAll.Returns <string>();
FunctionConfiguration topProductOfAllByCity = builder.EntityType <Product>().Collection.Function("TopProductOfAllByCity");
topProductOfAllByCity.Parameter <string>("city");
topProductOfAllByCity.Returns <string>();
FunctionConfiguration copyProductByCity = builder.EntityType <Product>().Function("CopyProductByCity");
copyProductByCity.Parameter <string>("city");
copyProductByCity.Returns <string>();
FunctionConfiguration topProductOfAllByCityAndModel = builder.EntityType <Product>().Collection.Function("TopProductOfAllByCityAndModel");
topProductOfAllByCityAndModel.Parameter <string>("city");
topProductOfAllByCityAndModel.Parameter <int>("model");
topProductOfAllByCityAndModel.Returns <string>();
// Function bound to the base entity type and derived entity type
builder.EntityType <RoutingCustomer>().Function("GetOrdersCount").Returns <string>();
builder.EntityType <VIP>().Function("GetOrdersCount").Returns <string>();
// Overloaded function only bound to the base entity type with one paramter
var getOrderCount = builder.EntityType <RoutingCustomer>().Function("GetOrdersCount");
getOrderCount.Parameter <int>("factor");
getOrderCount.Returns <string>();
// Function only bound to the derived entity type
builder.EntityType <SpecialVIP>().Function("GetSpecialGuid").Returns <string>();
// Function bound to the collection of the base and the derived entity type
builder.EntityType <RoutingCustomer>().Collection.Function("GetAllEmployees").Returns <string>();
builder.EntityType <VIP>().Collection.Function("GetAllEmployees").Returns <string>();
// Bound function with enum type parameters
var boundFunction = builder.EntityType <RoutingCustomer>().Collection.Function("BoundFuncWithEnumParameters");
boundFunction.Parameter <SimpleEnum>("SimpleEnum");
boundFunction.Parameter <FlagsEnum>("FlagsEnum");
boundFunction.Returns <string>();
// Bound function with enum type parameter for attribute routing
var boundFunctionForAttributeRouting = builder.EntityType <RoutingCustomer>().Collection
.Function("BoundFuncWithEnumParameterForAttributeRouting");
boundFunctionForAttributeRouting.Parameter <SimpleEnum>("SimpleEnum");
boundFunctionForAttributeRouting.Returns <string>();
// Unbound function with enum type parameters
var function = builder.Function("UnboundFuncWithEnumParameters");
function.Parameter <LongEnum>("LongEnum");
function.Parameter <FlagsEnum>("FlagsEnum");
function.Returns <string>();
// Unbound function
builder.Function("UnboundFunction").ReturnsCollection <int>().IsComposable = true;
// Action only bound to the derived entity type
builder.EntityType <SpecialVIP>().Action("ActionBoundToSpecialVIP");
// Action only bound to the derived entity type
builder.EntityType <SpecialVIP>().Collection.Action("ActionBoundToSpecialVIPs");
// Function only bound to the base entity collection type
builder.EntityType <RoutingCustomer>().Collection.Function("FunctionBoundToRoutingCustomers").Returns <int>();
// Function only bound to the derived entity collection type
builder.EntityType <VIP>().Collection.Function("FunctionBoundToVIPs").Returns <int>();
// Bound function with multiple parameters
var functionBoundToProductWithMultipleParamters = builder.EntityType <Product>().Function("FunctionBoundToProductWithMultipleParamters");
functionBoundToProductWithMultipleParamters.Parameter <int>("P1");
functionBoundToProductWithMultipleParamters.Parameter <int>("P2");
functionBoundToProductWithMultipleParamters.Parameter <string>("P3");
functionBoundToProductWithMultipleParamters.Returns <int>();
// Overloaded bound function with no parameter
builder.EntityType <Product>().Function("FunctionBoundToProduct").Returns <int>();
// Overloaded bound function with one parameter
builder.EntityType <Product>().Function("FunctionBoundToProduct").Returns <int>().Parameter <int>("P1");
// Overloaded bound function with multiple parameters
var functionBoundToProduct = builder.EntityType <Product>().Function("FunctionBoundToProduct").Returns <int>();
functionBoundToProduct.Parameter <int>("P1");
functionBoundToProduct.Parameter <int>("P2");
functionBoundToProduct.Parameter <string>("P3");
// Unbound function with one parameter
var unboundFunctionWithOneParamters = builder.Function("UnboundFunctionWithOneParamters");
unboundFunctionWithOneParamters.Parameter <int>("P1");
unboundFunctionWithOneParamters.ReturnsFromEntitySet <RoutingCustomer>("RoutingCustomers");
unboundFunctionWithOneParamters.IsComposable = true;
// Unbound function with multiple parameters
var functionWithMultipleParamters = builder.Function("UnboundFunctionWithMultipleParamters");
functionWithMultipleParamters.Parameter <int>("P1");
functionWithMultipleParamters.Parameter <int>("P2");
functionWithMultipleParamters.Parameter <string>("P3");
functionWithMultipleParamters.Returns <int>();
// Overloaded unbound function with no parameter
builder.Function("OverloadUnboundFunction").Returns <int>();
// Overloaded unbound function with one parameter
builder.Function("OverloadUnboundFunction").Returns <int>().Parameter <int>("P1");
// Overloaded unbound function with multiple parameters
var overloadUnboundFunction = builder.Function("OverloadUnboundFunction").Returns <int>();
overloadUnboundFunction.Parameter <int>("P1");
overloadUnboundFunction.Parameter <int>("P2");
overloadUnboundFunction.Parameter <string>("P3");
var functionWithComplexTypeParameter =
builder.EntityType <RoutingCustomer>().Function("CanMoveToAddress").Returns <bool>();
functionWithComplexTypeParameter.Parameter <Address>("address");
var functionWithCollectionOfComplexTypeParameter =
builder.EntityType <RoutingCustomer>().Function("MoveToAddresses").Returns <bool>();
functionWithCollectionOfComplexTypeParameter.CollectionParameter <Address>("addresses");
var functionWithCollectionOfPrimitiveTypeParameter =
builder.EntityType <RoutingCustomer>().Function("CollectionOfPrimitiveTypeFunction").Returns <bool>();
functionWithCollectionOfPrimitiveTypeParameter.CollectionParameter <int>("intValues");
var functionWithEntityTypeParameter =
builder.EntityType <RoutingCustomer>().Function("EntityTypeFunction").Returns <bool>();
functionWithEntityTypeParameter.EntityParameter <Product>("product");
var functionWithCollectionEntityTypeParameter =
builder.EntityType <RoutingCustomer>().Function("CollectionEntityTypeFunction").Returns <bool>();
functionWithCollectionEntityTypeParameter.CollectionEntityParameter <Product>("products");
return(_model = builder.GetEdmModel());
}
public void CanCreateActionWithNonBindingParameters()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = new ActionConfiguration(builder, "MyAction");
action.Parameter<string>("p0");
action.Parameter<int>("p1");
action.Parameter<Address>("p2");
action.CollectionParameter<string>("p3");
action.CollectionParameter<int>("p4");
action.CollectionParameter<ZipCode>("p5");
ParameterConfiguration[] parameters = action.Parameters.ToArray();
ComplexTypeConfiguration[] complexTypes = builder.StructuralTypes.OfType<ComplexTypeConfiguration>().ToArray();
// Assert
Assert.Equal(2, complexTypes.Length);
Assert.Equal(typeof(Address).FullName, complexTypes[0].FullName);
Assert.Equal(typeof(ZipCode).FullName, complexTypes[1].FullName);
Assert.Equal(6, parameters.Length);
Assert.Equal("p0", parameters[0].Name);
Assert.Equal("Edm.String", parameters[0].TypeConfiguration.FullName);
Assert.Equal("p1", parameters[1].Name);
Assert.Equal("Edm.Int32", parameters[1].TypeConfiguration.FullName);
Assert.Equal("p2", parameters[2].Name);
Assert.Equal(typeof(Address).FullName, parameters[2].TypeConfiguration.FullName);
Assert.Equal("p3", parameters[3].Name);
Assert.Equal("Collection(Edm.String)", parameters[3].TypeConfiguration.FullName);
Assert.Equal("p4", parameters[4].Name);
Assert.Equal("Collection(Edm.Int32)", parameters[4].TypeConfiguration.FullName);
Assert.Equal("p5", parameters[5].Name);
Assert.Equal(string.Format("Collection({0})", typeof(ZipCode).FullName), parameters[5].TypeConfiguration.FullName);
}
public void CanCreateActionWithComplexReturnType()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration createAddress = new ActionConfiguration(builder, "CreateAddress");
createAddress.Returns<Address>();
ActionConfiguration createAddresses = new ActionConfiguration(builder, "CreateAddresses");
createAddresses.ReturnsCollection<Address>();
// Assert
IComplexTypeConfiguration address = createAddress.ReturnType as IComplexTypeConfiguration;
Assert.NotNull(address);
Assert.Equal(typeof(Address).FullName, address.FullName);
Assert.Null(createAddress.EntitySet);
ICollectionTypeConfiguration addresses = createAddresses.ReturnType as ICollectionTypeConfiguration;
Assert.NotNull(addresses);
Assert.Equal(string.Format("Collection({0})", typeof(Address).FullName), addresses.FullName);
address = addresses.ElementType as IComplexTypeConfiguration;
Assert.NotNull(address);
Assert.Equal(typeof(Address).FullName, address.FullName);
Assert.Null(createAddresses.EntitySet);
}
public ProtoDeclaredAction( ActionConfiguration a )
{
_action = a;
}
public void Apply_SetsActionLinkBuilder_OnlyIfActionIsBindable()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var vehicles = builder.EntitySet<Vehicle>("vehicles");
var paintAction = new ActionConfiguration(builder, "Paint");
_convention.Apply(paintAction, builder);
IEdmModel model = builder.GetEdmModel();
var paintEdmAction = model.EntityContainers().Single().Elements.OfType<IEdmFunctionImport>().Single();
ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(paintEdmAction);
Assert.Null(actionLinkBuilder);
}
private static void SetupExtendSupportDateActionLink(ActionConfiguration extendSupportDateAction)
{
extendSupportDateAction.HasActionLink(eic =>
{
Product pd = (Product)eic.EntityInstance;
return new Uri(eic.UrlHelper.Link(ODataRouteNames.InvokeBoundAction, new
{
controller = eic.EntitySet.Name,
boundId = pd.ID,
odataAction = "ExtendSupportDate"
}));
});
//extendSupportDateAction.HasActionLink(ActionLinkBuilder.CreateActionLinkFactory(
//baseFactory: eic =>
//{
// Product pd = (Product)eic.EntityInstance;
// return new Uri(eic.UrlHelper.Link(ODataRouteNames.InvokeBoundAction, new
// {
// controller = eic.EntitySet.Name,
// boundId = pd.ID,
// odataAction = "ExtendSupportDate"
// }));
//},
//expensiveAvailabilityCheck: eic =>
//{
// //do some check here and return true or false
// return true;
//}));
}
public void CanCreateActionWithEntityReturnType()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration createGoodCustomer = new ActionConfiguration(builder, "CreateGoodCustomer");
createGoodCustomer.ReturnsFromEntitySet<Customer>("GoodCustomers");
ActionConfiguration createBadCustomers = new ActionConfiguration(builder, "CreateBadCustomers");
createBadCustomers.ReturnsCollectionFromEntitySet<Customer>("BadCustomers");
// Assert
IEntityTypeConfiguration customer = createGoodCustomer.ReturnType as IEntityTypeConfiguration;
Assert.NotNull(customer);
Assert.Equal(typeof(Customer).FullName, customer.FullName);
IEntitySetConfiguration goodCustomers = builder.EntitySets.SingleOrDefault(s => s.Name == "GoodCustomers");
Assert.NotNull(goodCustomers);
Assert.Same(createGoodCustomer.EntitySet, goodCustomers);
ICollectionTypeConfiguration customers = createBadCustomers.ReturnType as ICollectionTypeConfiguration;
Assert.NotNull(customers);
customer = customers.ElementType as IEntityTypeConfiguration;
Assert.NotNull(customer);
IEntitySetConfiguration badCustomers = builder.EntitySets.SingleOrDefault(s => s.Name == "BadCustomers");
Assert.NotNull(badCustomers);
Assert.Same(createBadCustomers.EntitySet, badCustomers);
}
protected override ITestIt DoCreate(IActivityMonitor monitor, IRouteConfigurationLock configLock, ActionConfiguration c)
{
ActionTypeAttribute a = c.GetType().GetTypeInfo().GetCustomAttribute <ActionTypeAttribute>();
return((ITestIt)Activator.CreateInstance(a.ActionType, monitor, c));
}
public static ActionConfiguration ActionReturnsFromEntitySet <TEntityType>(ODataModelBuilder builder, ActionConfiguration action, string entitySetName) where TEntityType : class
{
action.NavigationSource = CreateOrReuseEntitySet <TEntityType>(builder, entitySetName);
action.ReturnType = builder.GetTypeConfigurationOrNull(typeof(TEntityType));
return(action);
}
public void CanCreateEdmModel_WithNonBindableAction()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
// Act
ActionConfiguration actionConfiguration = new ActionConfiguration(builder, "ActionName");
actionConfiguration.ReturnsFromEntitySet<Customer>("Customers");
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmEntityContainer container = model.EntityContainers().SingleOrDefault();
Assert.NotNull(container);
Assert.Equal(1, container.Elements.OfType<IEdmFunctionImport>().Count());
Assert.Equal(1, container.Elements.OfType<IEdmEntitySet>().Count());
IEdmFunctionImport action = container.Elements.OfType<IEdmFunctionImport>().Single();
Assert.False(action.IsComposable);
Assert.True(action.IsSideEffecting);
Assert.False(action.IsBindable);
Assert.Equal("ActionName", action.Name);
Assert.NotNull(action.ReturnType);
Assert.NotNull(action.EntitySet);
Assert.Equal("Customers", (action.EntitySet as IEdmEntitySetReferenceExpression).ReferencedEntitySet.Name);
Assert.Equal(typeof(Customer).FullName, (action.EntitySet as IEdmEntitySetReferenceExpression).ReferencedEntitySet.ElementType.FullName());
Assert.Empty(action.Parameters);
}
public async Task Setup_ActionRule_Sample_OnceEveryHour_And_between9and11_SendPictureToEmail()
{
//Create the hourly recurrence first and add to device
ScheduledEvent myHourlyRecurrence = new ScheduledEvent("HourlyRecurrence", new ICalendar(PulseInterval.HOURLY, 1));
ServiceResponse deviceResponse = await eventService.Add_ScheduledEventAsync(VALID_IP, VALID_USER, VALID_PASS, myHourlyRecurrence);
if (deviceResponse.IsSuccess) //Recurrence added
{
//Create the Weekdays evening schedule annd add to device
ScheduledEvent myWeeklyEveningSchedule = new ScheduledEvent("WorkingDays", new ICalendar(new ScheduleTime(17, 30), new ScheduleTime(21), new ScheduleDay[] { ScheduleDay.MO, ScheduleDay.TU, ScheduleDay.WE, ScheduleDay.TH, ScheduleDay.FR }));
deviceResponse = await eventService.Add_ScheduledEventAsync(VALID_IP, VALID_USER, VALID_PASS, myWeeklyEveningSchedule);
if (deviceResponse.IsSuccess) //Schedule added
{
//First get the possible templates for the device
GetActionTemplatesResponse aTemplates = await actionService.GetActionTemplatesAsync(VALID_IP, VALID_USER, VALID_PASS);
if (aTemplates.IsSuccess)
{
//Now create the action template based on template instance- Send SMTP with picture attached
ActionConfiguration SendSMTP = new ActionConfiguration(aTemplates.Templates["com.axis.action.fixed.notification.smtp"]);
//Set the action config paramters
SendSMTP.Parameters["subject"] = "Week evenings timeLapse";
SendSMTP.Parameters["message"] = "Photo %d";
SendSMTP.Parameters["email_to"] = "*****@*****.**";
SendSMTP.Parameters["email_from"] = "*****@*****.**";
SendSMTP.Parameters["host"] = "smtp-relay.gmail.com";
SendSMTP.Parameters["port"] = "587";
SendSMTP.Parameters["login"] = "";
SendSMTP.Parameters["password"] = "";
//Add the action config to the device
deviceResponse = await actionService.AddActionConfigurationAsync(VALID_IP, VALID_USER, VALID_PASS, SendSMTP);
if (deviceResponse.IsSuccess)
{
//Get the event instances suppported by the device, the collection will also contain our previously created schedule and recurrence event this way
GetEventInstancesResponse eInstances = await eventService.GetEventsInstancesAsync(VALID_IP, VALID_USER, VALID_PASS);
ActionRule OnEveryWeekDayEveningHourSendPicture = new ActionRule()
{
Name = "OnEveryWeekDayEveningHourSendPicture",
Enabled = true,
Trigger = eInstances.EventInstances.Find(x => x.TopicExpression == "tns1:UserAlarm/tnsaxis:Recurring/Pulse"), //See GetEventInstances output for the correct event name
Configuration = SendSMTP,
};
OnEveryWeekDayEveningHourSendPicture.Trigger.Parameters["id"].Value = myHourlyRecurrence.EventID;
//Create and add extra condition to Action Rule
EventTrigger OnWeekDayEveningSchedule = eInstances.EventInstances.Find(x => x.TopicExpression == "tns1:UserAlarm/tnsaxis:Recurring/Interval");
OnWeekDayEveningSchedule.Parameters["id"].Value = myWeeklyEveningSchedule.EventID;
OnWeekDayEveningSchedule.Parameters["active"].Value = "1";
OnEveryWeekDayEveningHourSendPicture.AddExtraCondition(OnWeekDayEveningSchedule);
//Create action rule on device
deviceResponse = await actionService.AddActionRuleAsync(VALID_IP, VALID_USER, VALID_PASS, OnEveryWeekDayEveningHourSendPicture);
Assert.IsTrue(deviceResponse.IsSuccess);
}
}
}
}
}
private static IEdmModel GetModel()
{
var config = RoutingConfigurationFactory.CreateWithTypes(typeof(Customer));
ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create(config);
builder.ContainerName = "C";
builder.Namespace = "A.B";
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
// bound actions
ActionConfiguration primitive = customer.Action("Primitive");
primitive.Parameter <int>("Quantity");
primitive.Parameter <string>("ProductCode");
primitive.Parameter <Date>("Birthday");
primitive.Parameter <AColor>("BkgColor");
primitive.Parameter <AColor?>("InnerColor");
ActionConfiguration complex = customer.Action("Complex");
complex.Parameter <int>("Quantity");
complex.Parameter <MyAddress>("Address");
ActionConfiguration enumType = customer.Action("Enum");
enumType.Parameter <AColor>("Color");
ActionConfiguration primitiveCollection = customer.Action("PrimitiveCollection");
primitiveCollection.Parameter <string>("Name");
primitiveCollection.CollectionParameter <int>("Ratings");
primitiveCollection.CollectionParameter <TimeOfDay>("Time");
primitiveCollection.CollectionParameter <AColor?>("Colors");
ActionConfiguration complexCollection = customer.Action("ComplexCollection");
complexCollection.Parameter <string>("Name");
complexCollection.CollectionParameter <MyAddress>("Addresses");
ActionConfiguration enumCollection = customer.Action("EnumCollection");
enumCollection.CollectionParameter <AColor>("Colors");
ActionConfiguration entity = customer.Action("Entity");
entity.Parameter <int>("Id");
entity.EntityParameter <Customer>("Customer");
entity.EntityParameter <Customer>("NullableCustomer");
ActionConfiguration entityCollection = customer.Action("EntityCollection");
entityCollection.Parameter <int>("Id");
entityCollection.CollectionEntityParameter <Customer>("Customers");
// unbound actions
ActionConfiguration unboundPrimitive = builder.Action("UnboundPrimitive");
unboundPrimitive.Parameter <int>("Quantity");
unboundPrimitive.Parameter <string>("ProductCode");
unboundPrimitive.Parameter <Date>("Birthday");
unboundPrimitive.Parameter <AColor>("BkgColor");
unboundPrimitive.Parameter <AColor?>("InnerColor");
ActionConfiguration unboundComplex = builder.Action("UnboundComplex");
unboundComplex.Parameter <int>("Quantity");
unboundComplex.Parameter <MyAddress>("Address");
ActionConfiguration unboundEnum = builder.Action("UnboundEnum");
unboundEnum.Parameter <AColor>("Color");
ActionConfiguration unboundPrimitiveCollection = builder.Action("UnboundPrimitiveCollection");
unboundPrimitiveCollection.Parameter <string>("Name");
unboundPrimitiveCollection.CollectionParameter <int>("Ratings");
unboundPrimitiveCollection.CollectionParameter <TimeOfDay>("Time");
unboundPrimitiveCollection.CollectionParameter <AColor?>("Colors");
ActionConfiguration unboundComplexCollection = builder.Action("UnboundComplexCollection");
unboundComplexCollection.Parameter <string>("Name");
unboundComplexCollection.CollectionParameter <MyAddress>("Addresses");
ActionConfiguration unboundEnumCollection = builder.Action("UnboundEnumCollection");
unboundEnumCollection.CollectionParameter <AColor>("Colors");
ActionConfiguration unboundEntity = builder.Action("UnboundEntity");
unboundEntity.Parameter <int>("Id");
unboundEntity.EntityParameter <Customer>("Customer").Nullable = false;
unboundEntity.EntityParameter <Customer>("NullableCustomer");
ActionConfiguration unboundEntityCollection = builder.Action("UnboundEntityCollection");
unboundEntityCollection.Parameter <int>("Id");
unboundEntityCollection.CollectionEntityParameter <Customer>("Customers");
return(builder.GetEdmModel());
}
public IActionExecutor GetActionExecutor(ActionConfiguration actionConfiguration)
{
return(actionConfiguration switch
{
{ Type : ActionType.AnswerToMessage } => new AnswerMessageActionExecutor(_slackClient, actionConfiguration.Value),
/// <summary>
/// Overrides (replaces) an <see cref="ActionConfiguration"/> at a specified index.
/// </summary>
/// <param name="idx">Index to replace.</param>
/// <param name="action">The new action to inject.</param>
internal void Override( int idx, ActionConfiguration action )
{
if( action == null ) throw new ArgumentNullException( "action" );
_children[idx] = action;
}
/// <summary>
/// Adds an <see cref="ActionConfiguration"/> to this composite.
/// </summary>
/// <param name="action">The action to add.</param>
protected void Add( ActionConfiguration action )
{
if( action == null ) throw new ArgumentNullException( "action" );
_children.Add( action );
}
public void HasActionLink_SetsFollowsConventions(bool value)
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = new ActionConfiguration(builder, "IgnoreAction");
Mock<IEdmTypeConfiguration> bindingParameterTypeMock = new Mock<IEdmTypeConfiguration>();
bindingParameterTypeMock.Setup(o => o.Kind).Returns(EdmTypeKind.Entity);
IEdmTypeConfiguration bindingParameterType = bindingParameterTypeMock.Object;
action.SetBindingParameter("IgnoreParameter", bindingParameterType, alwaysBindable: false);
// Act
action.HasActionLink((a) => { throw new NotImplementedException(); }, followsConventions: value);
// Assert
Assert.Equal(value, action.FollowsConventions);
}
public static void Register(HttpConfiguration config)
{
// Cross-Origin Resource Sharing
var cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// Set timezone
config.SetTimeZoneInfo(TimeZoneInfo.Utc);
// Custom authentication
config.Filters.Add(new BrizbeeAuthorizeAttribute());
// Custom exception handling
config.Filters.Add(new CustomExceptionFilterAttribute());
// Web API configuration and services
ODataModelBuilder builder = new ODataConventionModelBuilder();
config.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Commit>("Commits");
builder.EntitySet <Job>("Jobs");
builder.EntitySet <Organization>("Organizations");
builder.EntitySet <Punch>("Punches");
builder.EntitySet <Rate>("Rates");
builder.EntitySet <QuickBooksDesktopExport>("QuickBooksDesktopExports");
builder.EntitySet <Task>("Tasks");
builder.EntitySet <TaskTemplate>("TaskTemplates");
builder.EntitySet <TimesheetEntry>("TimesheetEntries");
builder.EntitySet <User>("Users");
// Collection Function - Jobs/Open
builder.EntityType <Job>()
.Collection
.Function("Open")
.ReturnsCollectionFromEntitySet <Job>("Jobs");
// Collection Function - Punches/Current
builder.EntityType <Punch>()
.Collection
.Function("Current")
.ReturnsFromEntitySet <Punch>("Punches");
// Member Function - Commit/Export
var export = builder.EntityType <Commit>()
.Function("Export")
.Returns <string>();
export.Parameter <string>("Delimiter");
// Collection Action - Users/Authenticate
var authenticate = builder.EntityType <User>()
.Collection
.Action("Authenticate");
authenticate.Parameter <Session>("Session");
authenticate.Returns <Credential>();
// Collection Action - Customers/NextNumber
builder.EntityType <Customer>()
.Collection
.Action("NextNumber");
// Collection Action - Jobs/NextNumber
builder.EntityType <Job>()
.Collection
.Action("NextNumber");
// Collection Action - Tasks/NextNumber
builder.EntityType <Task>()
.Collection
.Action("NextNumber");
// Collection Function - Organizations/Countries
var countries = builder.EntityType <Organization>()
.Collection
.Function("Countries");
countries.ReturnsCollection <Country>();
// Collection Function - Organizations/TimeZones
var timeZones = builder.EntityType <Organization>()
.Collection
.Function("TimeZones");
timeZones.ReturnsCollection <IanaTimeZone>();
// Collection Action - Users/Register
var register = builder.EntityType <User>()
.Collection
.Action("Register");
register.Parameter <Organization>("Organization");
register.Parameter <User>("User");
register.ReturnsFromEntitySet <User>("Users");
// Collection Action - Punches/PunchIn
var punchIn = builder.EntityType <Punch>()
.Collection
.Action("PunchIn")
.ReturnsFromEntitySet <Punch>("Punches");
punchIn.Parameter <int>("TaskId");
punchIn.Parameter <string>("InAtTimeZone");
punchIn.Parameter <string>("LatitudeForInAt");
punchIn.Parameter <string>("LongitudeForInAt");
punchIn.Parameter <string>("SourceHardware");
punchIn.Parameter <string>("SourceOperatingSystem");
punchIn.Parameter <string>("SourceOperatingSystemVersion");
punchIn.Parameter <string>("SourceBrowser");
punchIn.Parameter <string>("SourceBrowserVersion");
// Collection Action - Punches/PunchOut
var punchOut = builder.EntityType <Punch>()
.Collection
.Action("PunchOut")
.ReturnsFromEntitySet <Punch>("Punches");
punchOut.Parameter <string>("OutAtTimeZone");
punchOut.Parameter <string>("LatitudeForOutAt");
punchOut.Parameter <string>("LongitudeForOutAt");
punchOut.Parameter <string>("SourceHardware");
punchOut.Parameter <string>("SourceOperatingSystem");
punchOut.Parameter <string>("SourceOperatingSystemVersion");
punchOut.Parameter <string>("SourceBrowser");
punchOut.Parameter <string>("SourceBrowserVersion");
// Collection Function - Punches/Download
var download = builder.EntityType <Punch>()
.Collection
.Function("Download")
.Returns <string>();
download.Parameter <int>("CommitId");
// Collection Function - Tasks/Search
var tasksSearch = builder.EntityType <Task>()
.Collection
.Function("Search")
.Returns <string>();
tasksSearch.Parameter <string>("Number");
// Collection Function - Tasks/ForPunches
var tasksForPunches = builder.EntityType <Task>()
.Collection
.Function("ForPunches");
tasksForPunches.Parameter <string>("InAt");
tasksForPunches.Parameter <string>("OutAt");
tasksForPunches.ReturnsCollectionFromEntitySet <Task>("Tasks");
// Collection Action - TimesheetEntries/Add
var add = builder.EntityType <TimesheetEntry>()
.Collection
.Action("Add")
.ReturnsFromEntitySet <TimesheetEntry>("TimesheetEntries");
add.Parameter <int>("TaskId");
add.Parameter <int>("Minutes");
add.Parameter <string>("EnteredAt");
add.Parameter <string>("Notes");
// Collection Function - Rates/BasePayrollRatesForPunches
var basePayrollRates = builder.EntityType <Rate>()
.Collection
.Function("BasePayrollRatesForPunches");
basePayrollRates.Parameter <string>("InAt");
basePayrollRates.Parameter <string>("OutAt");
basePayrollRates.ReturnsCollectionFromEntitySet <Rate>("Rates");
// Collection Function - Rates/BaseServiceRatesForPunches
var baseServiceRates = builder.EntityType <Rate>()
.Collection
.Function("BaseServiceRatesForPunches");
baseServiceRates.Parameter <string>("InAt");
baseServiceRates.Parameter <string>("OutAt");
baseServiceRates.ReturnsCollectionFromEntitySet <Rate>("Rates");
// Collection Function - Rates/AlternatePayrollRatesForPunches
var alternatePayrollRates = builder.EntityType <Rate>()
.Collection
.Function("AlternatePayrollRatesForPunches");
alternatePayrollRates.Parameter <string>("InAt");
alternatePayrollRates.Parameter <string>("OutAt");
alternatePayrollRates.ReturnsCollectionFromEntitySet <Rate>("Rates");
// Collection Function - Rates/AlternateServiceRatesForPunches
var alternateServiceRates = builder.EntityType <Rate>()
.Collection
.Function("AlternateServiceRatesForPunches");
alternateServiceRates.Parameter <string>("InAt");
alternateServiceRates.Parameter <string>("OutAt");
alternateServiceRates.ReturnsCollectionFromEntitySet <Rate>("Rates");
// Collection Action - Punches/Split
var split = builder.EntityType <Punch>()
.Collection
.Action("Split");
split.Parameter <string>("InAt");
split.Parameter <string>("Minutes");
split.Parameter <string>("OutAt");
split.Parameter <string>("Time");
split.Parameter <string>("Type");
// Collection Action - Punches/SplitAtMidnight
var splitMidnight = builder.EntityType <Punch>()
.Collection
.Action("SplitAtMidnight");
splitMidnight.Parameter <string>("InAt");
splitMidnight.Parameter <string>("OutAt");
// Collection Action - Punches/PopulateRates
var populate = builder.EntityType <Punch>()
.Collection
.Action("PopulateRates");
populate.Parameter <PopulateRateOptions>("Options");
populate.Returns <string>();
// Member Action - User/ChangePassword
ActionConfiguration changePassword = builder.EntityType <User>()
.Action("ChangePassword");
changePassword.Parameter <string>("Password");
// Member Action - Commit/Undo
ActionConfiguration undo = builder.EntityType <Commit>()
.Action("Undo");
config.MapODataServiceRoute("odata", "odata", builder.GetEdmModel());
config.EnableDependencyInjection();
config.EnsureInitialized();
}