public void Build(IFunctionHostBuilder builder)
{
JsonConvert.DefaultSettings = () =>
{
return(new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
};
builder
.Setup((serviceCollection, commandRegistry) =>
{
serviceCollection.AddSingleton((_) => CosmosStoreFactory.GetCosmosStore <Process>());
commandRegistry.Discover(this.GetType().Assembly);
})
.OpenApiEndpoint(openApi => openApi
.Title("Functions REST API")
.Version("0.0.0")
.UserInterface()
)
.Functions(functions => functions
.HttpRoute("/api/v1/process", route => route
.HttpFunction <GetProcessQuery>(HttpMethod.Get)
.HttpFunction <GetProcessByIdQuery>("/{id}", HttpMethod.Get)
.HttpFunction <CreateProcessCommand>(HttpMethod.Post)
.HttpFunction <MarkProcessAsSuccessfulCommand>("/succeeded", HttpMethod.Put)
.HttpFunction <MarkProcessAsFailedCommand>("/failed", HttpMethod.Put)
)
);
}
public void Build(IFunctionHostBuilder builder)
{
builder
.Setup((serviceCollection, commandRegistry) =>
{
commandRegistry.Register <HelloWorldCommandHandler>();
commandRegistry.Register <AddCommandHandler>();
})
.OpenApiEndpoint(openApi => openApi
.Title("A Simple API")
.Version("0.0.0")
.UserInterface()
)
.Functions(functions => functions
/*.HttpRoute("/HelloWorld", route => route
* .HttpFunction<HelloWorldCommand>("/{name}", HttpMethod.Get)
* .OpenApiDescription("Says hello world")
* )
* .OpenApiDescription("A route description")*/
/*.HttpRoute("/Add", route => route
* .HttpFunction<AddCommand>(AuthorizationTypeEnum.Anonymous,HttpMethod.Post)
* .OpenApiDescription("Adds two numbers together")
* .OpenApiResponse(400, "Some sort of error")
* )
* .OpenApiName("HelloWorld")*/
//.Timer<HelloWorldCommand, HelloWorldTimerCommandFactory>("*/5 * * * * *")
.Storage("StorageConnectionString", storage => storage
.BlobFunction <HelloWorldCommand>("triggertest/{name}"))
);
}
/// <summary>
/// Injecting IFunctionHostBuilder
/// </summary>
/// <param name="builder"></param>
public void Build(IFunctionHostBuilder builder)
{
JsonConvert.DefaultSettings = () =>
{
return(new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
};
//Using IFunctionBuilder that is passed into our configuration class exposes a fluent API that allows us to define our functions
builder
//This is the first step and is used to call the setup method which allows us to
//configure our dependencies for dependecny injection using the provided service collection
//and register our command handlers
.Setup((serviceCollection, commandRegistry) =>
{
//Injecting CosmosStoreFactory
serviceCollection.AddSingleton((_) => CosmosRatingFactory.GetCosmosStore <RatingModel>());
//using Discover method provided by the command registry to locate and register any command handlers in my assembly
commandRegistry.Discover(this.GetType().Assembly);
})
//OpenApiEndPoint configures the Open API definition for out API and Configures the Swagger user interface
//that will allow us to explore and use our API.
.OpenApiEndpoint(openApi => openApi
.Title("openhack REST API")
.Version("1.0.0")
.UserInterface()
)
//Defining configuration for our functions.
//This example is only covering HTTP functions
//for other triggers please check this: https://functionmonkey.azurefromthetrenches.com
.Functions(functions => functions
.HttpRoute("/api/v1/product", route => route
//Get Product by Id
.HttpFunction <GetProductIdQuery>("/{id}", AuthorizationTypeEnum.Anonymous, HttpMethod.Get)
)
.OpenApiDescription("Methods on this route represent the Product Api")
.OpenApiName("Product Api")
.HttpRoute("/api/v1/rating", route => route
//Get All Ratings
.HttpFunction <GetRatingsQuery>(AuthorizationTypeEnum.Anonymous, HttpMethod.Get).OpenApiDescription("Get Ratings Query")
//Get Rating by Id
.HttpFunction <GetRatingsByIdQuery>("/{id}", AuthorizationTypeEnum.Anonymous, HttpMethod.Get).OpenApiDescription("Get Rating By Id Query")
//Create Rating
.HttpFunction <CreateRatingCommand>(AuthorizationTypeEnum.Anonymous, HttpMethod.Post).OpenApiDescription("Create Rating Command")
)
.OpenApiDescription("Methods on this route represent the Rating Api")
.OpenApiName("Rating Api")
);
}
public void Build(IFunctionHostBuilder host)
{
host
.Setup((serviceCollection, commandRegistry) =>
{
serviceCollection.AddProductApplication(commandRegistry);
})
.Functions(functions => functions
.HttpRoute("/api/v1/product", route => route
.HttpFunction <GetProductQuery>()
)
);
}
public void Build(IFunctionHostBuilder builder)
{
builder
.Setup((serviceCollection, commandRegistry) =>
{
serviceCollection.AddApplication(commandRegistry);
})
.Functions(functions => functions
.HttpRoute("/api/v1/post", route => route
.HttpFunction <AddPostCommand>(HttpMethod.Post)
)
);
}
public void Build(IFunctionHostBuilder builder)
{
builder
.Setup((serviceCollection, commandRegistry) =>
{
ApplicationSettings applicationSettings = new ApplicationSettings
{
CosmosContainerName = "todoItems",
CosmosDatabaseName = "testdatabase",
CosmosConnectionString =
Environment.GetEnvironmentVariable("cosmosConnectionString", EnvironmentVariableTarget.Process)
};
serviceCollection
.AddSingleton(applicationSettings)
.AddTransient <IToDoItemRepository, ToDoItemRepository>()
.AddValidatorsFromAssemblyContaining <FunctionAppConfiguration>()
.AddSingleton <ITelemetry, Telemetry>()
.Replace(
new ServiceDescriptor(
typeof(ICommandDispatcher),
typeof(CustomDispatcher),
ServiceLifetime.Transient)
)
;
commandRegistry.Discover <FunctionAppConfiguration>();
})
.AddFluentValidation()
.Authorization(authorization => authorization
.TokenValidator <TokenValidator>()
.AuthorizationDefault(AuthorizationTypeEnum.TokenValidation)
.Claims(claims => claims
.MapClaimToPropertyName("userId", "UserId")
)
)
.DefaultHttpResponseHandler <HttpResponseHandler>()
.OpenApiEndpoint(openApi => openApi
.Title("ToDo API")
.Version("1.0.0")
.UserInterface()
)
.Functions(functions => functions
.HttpRoute("api/v1/todoItem", route => route
.HttpFunction <AddToDoItemCommand>(HttpMethod.Post)
.HttpFunction <GetAllToDoItemsQuery>(HttpMethod.Get)
.HttpFunction <MarkItemCompleteCommand>("/{itemId}/complete", HttpMethod.Put)
)
.ServiceBus(serviceBus => serviceBus
.QueueFunction <AddToDoItemCommand>("newtodoitem")
)
);
}
public void Build(IFunctionHostBuilder builder)
{
builder
.Setup((serviceCollection, commandRegistry) =>
commandRegistry.Register <HelloWorldCommandHandler>()
)
.Functions(functions => functions
.Storage(StorageConnectionName, storage => storage
.BlobFunction <HelloWorldCommand>($"{ContainerName}/{{name}}")
)
)
//.OutputAuthoredSource(@"D:\Lib\Azure Functions\wip\outputfolder")
;
}
public void Build(IFunctionHostBuilder builder)
{
builder
.Setup((serviceCollection, commandRegistry) =>
{
serviceCollection
.AddTransient <IMarker, Marker>()
.AddValidatorsFromAssemblyContaining <HttpCommandWithNoResultAndValidatorThatFailsValidator>()
;
})
.AddFluentValidation()
.OpenApiEndpoint(openApi => openApi
.UserInterface()
.Title("Integration Test Functions")
.Version("1.0.0")
)
.Authorization(authorization => authorization
.AuthorizationDefault(AuthorizationTypeEnum.Anonymous)
.TokenValidator <MockTokenValidator>()
.Claims(claims => claims
.MapClaimToPropertyName("claima", "StringClaim")
.MapClaimToCommandProperty <HttpIntClaimCommand>("claimb", cmd => cmd.MappedValue)
)
)
.DefaultConnectionStringSettingNames(settingNames =>
{
// These are the default values - you don't have to set them
// I've set them here just to show what they are
settingNames.Storage = "storageConnectionString";
settingNames.CosmosDb = "cosmosConnectionString";
settingNames.ServiceBus = "serviceBusConnectionString";
settingNames.SignalR = "signalRConnectionString";
})
.DefaultHttpHeaderBindingConfiguration(new HeaderBindingConfiguration()
{
PropertyFromHeaderMappings = new Dictionary <string, string>
{
{ "DefaultHeaderIntValue", "x-default-int" },
{ "DefaultHeaderStringValue", "x-default-string" }
}
})
.Functions(functions =>
{
CreateCommonFunctions(functions);
CreateAdditionalFunctions(functions);
});
}
public void Build(IFunctionHostBuilder builder)
{
builder
.Setup((sc, cr) =>
{
sc.AddSingleton <IRepository, Repository>();
cr.Discover <FunctionAppConfiguration>();
})
.Functions(functions => functions
.HttpRoute("todo", route => route
.HttpFunction <GetAllToDoItemsQuery>(HttpMethod.Get)
.HttpFunction <CreateToDoItemCommand>(HttpMethod.Post)
.HttpFunction <MarkToDoItemCompleteCommand>("/complete", HttpMethod.Put)
)
)
;
}
public void Build(IFunctionHostBuilder builder)
{
builder
.Setup((services, commands) =>
{
services.AddConfiguration();
services.AddTransient <TelemetryClient>(x => new TelemetryClient());
#if SUPPORTS_BIGINTEGER
commands.Register <FibonacciCommandHandler>();
services.AddTransient <IValidator <FibonacciCommand>, FibonacciCommandValidator>();
#else
commands.Register <FibLongCommandHandler>();
services.AddTransient <IValidator <FibLongCommand>, FibLongCommandValidator>();
#endif
commands.Register <ReverseWordsCommandHandler>();
services.AddTransient <IValidator <ReverseWordsCommand>, ReverseWordsCommandValidator>();
commands.Register <TriangleTypeCommandHandler>();
services.AddTransient <IValidator <TriangleTypeCommand>, TriangleTypeValidator>();
commands.Register <GetApiTokenCommandHandler>();
})
.AddFluentValidation()
.Authorization(auth => auth.AuthorizationDefault(AuthorizationTypeEnum.Anonymous))
.Functions(functions => functions
.HttpRoute("/api/Fibonacci",
#if SUPPORTS_BIGINTEGER
route => route.HttpFunction <FibonacciCommand>(HttpMethod.Get)
#else
route => route.HttpFunction <FibLongCommand>(HttpMethod.Get)
#endif
)
.HttpRoute("/api/TriangleType", route => route.HttpFunction <TriangleTypeCommand>(HttpMethod.Get))
.HttpRoute("/api/ReverseWords", route => route.HttpFunction <ReverseWordsCommand>(HttpMethod.Get))
.HttpRoute("/api/Token", route => route.HttpFunction <GetApiTokenCommand>(HttpMethod.Get))
)
.OpenApiEndpoint(openapi =>
openapi
.Title("KnockKnock Tones")
.Version("0.0.1")
.UserInterface())
// .OutputAuthoredSource(@"c:\projects\kkoutput")
;
}
public void Build(IFunctionHostBuilder builder)
{
builder
.Setup((serviceCollection, commandRegistry) =>
{
serviceCollection
.AddApplication(commandRegistry)
.AddAutoMapper(typeof(SubsystemRegistration))
;
})
.AddFluentValidation()
.DefaultHttpResponseHandler <HttpResponseHandler>()
.Functions(functions => functions
.HttpRoute("/api/v1/post", route => route
.HttpFunction <AddPostCommand>(HttpMethod.Post)
.HttpFunction <GetPostQuery>("/{postId}", HttpMethod.Get)
)
);
}
