public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { serviceCollection .AddTransient <IValidator <BlobCommand>, BlobCommandValidator>() .AddTransient <IValidator <SimpleHttpRouteCommand>, SimpleHttpRouteCommandValidator>() .AddTransient <IValidator <StorageQueueCommand>, StorageQueueCommandValidator>() ; commandRegistry.Discover <FunctionAppConfiguration>(); }) .AddFluentValidation() //.OutputAuthoredSource(@"c:\wip\outputsource") .Functions(functions => functions .HttpRoute("simpleHttp", route => route .HttpFunction <SimpleHttpRouteCommand>()) .Storage("storageAccount", storage => storage .QueueFunction <StorageQueueCommand>("myqueue") .BlobFunction <BlobCommand>("blobcommandcontainer/{name}") // TODO: We need to have the compiler insert parameters on the function for everything surrounded in {} - e.g. {name} needs a string parameter of name .BlobFunction <StreamBlobCommand>("streamblobcommandcontainer/{name}") ) .CosmosDb("cosmosConnection", cosmos => cosmos .ChangeFeedFunction <SimpleCosmosChangeFeedCommand>("cosmosCollection", "cosmosDatabase") ) .ServiceBus("serviceBuConnection", serviceBus => serviceBus .QueueFunction <SimpleServiceBusQueueCommand>("myqueue") .SubscriptionFunction <SimpleServiceBusTopicCommand>("mytopic", "mysubscription") ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { var configurationBuilder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); IConfigurationRoot configuration = configurationBuilder.Build(); serviceCollection.RegisterMapper(); serviceCollection.RegisterRepositories(); serviceCollection.RegisterServices(); serviceCollection.RegisterValidators(); serviceCollection.AddDbContext <UserDbContext>( options => options.UseSqlServer(configuration.GetConnectionString("DefaultConnection")), ServiceLifetime.Transient); }) .Functions(functions => functions .HttpRoute("users", route => route .HttpFunction <GetUsersQuery>(HttpMethod.Get) .HttpFunction <GetUserByIdQuery>("/{id}", HttpMethod.Get) .HttpFunction <CreateUserCommand>(HttpMethod.Post) .HttpFunction <UpdateUserCommand>(HttpMethod.Put) .HttpFunction <DeleteUserCommand>("/{id}", HttpMethod.Delete) .HttpFunction <GetUserByCityQuery>("/{city}", HttpMethod.Get)) .ServiceBus(ServiceBusConnectionName, serviceBus => serviceBus .SubscriptionFunction <AddUserCommand>(TopicName, SubscriptionName))); }
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}")) ); }
public void Build(IFunctionHostBuilder builder) { JsonConvert.DefaultSettings = () => { return(new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); }; builder .Setup((serviceCollection, commandRegistry) => { commandRegistry.Register <TenantQueryCommandHandler>(); commandRegistry.Register <CreateTenantCommandHandler>(); serviceCollection.AddHttpClient <Services2.TableauService>(); serviceCollection.AddSingleton(c => new SnowflakeService()); serviceCollection.AddSingleton(c => new ArtifactService()); }) .Functions(functions => functions .HttpRoute("v1/red2/tenant", route => route .HttpFunction <TenantQueryCommand>("/{name}", HttpMethod.Get) .HttpFunction <CreateTenantCommand>(HttpMethod.Post) ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { commandRegistry.Register <HelloWorldCommandHandler>(); commandRegistry.Register <AddCommandHandler>(); commandRegistry.Register <CosmosCommandHandler>(); commandRegistry.Register <CosmosDocumentCommandHandler>(); commandRegistry.Register <CosmosDocumentBatchCommandHandler>(); serviceCollection.AddLogging(); }) .OpenApiEndpoint(openApi => openApi .Title("A Simple API") .Version("0.1.0") .ApiSpecVersion(ApiSpecVersion.OpenApi2_0) .ApiOutputFormat(ApiOutputFormat.Json) .UserInterface() ) //.OutputAuthoredSource(@"c:\wip\scratch\outputSource") .Functions(functions => functions .HttpRoute("/HelloWorld", route => route .HttpFunction <HelloWorldCommand>("/{name}", AuthorizationTypeEnum.Anonymous, HttpMethod.Get) .OpenApiDescription("Says hello world") .Options(options => options .AddHeaderMapping(x => x.HeaderName, "x-header-name") .ResponseHandler <CustomResponseHandler>() ) ) .HttpRoute("/Form", route => route .HttpFunction <FormCommand>(HttpMethod.Post) ) .OpenApiDescription("A route description") .CosmosDb("CosmosConnection", cosmos => cosmos .ChangeFeedFunction <CosmosCommand, ExampleCosmosErrorHandler>("Items", "ToDoList", leaseCollectionPrefix: "fn1") //, convertToPascalCase:true) //.ChangeFeedFunction<CosmosDocumentCommand>("Items", "ToDoList") //.ChangeFeedFunction<CosmosDocumentBatchCommand>("Items", "ToDoList", leaseCollectionPrefix:"fn2") ) .HttpRoute("/Add", route => route .HttpFunction <AddCommand>(AuthorizationTypeEnum.Anonymous, HttpMethod.Post) .OpenApiDescription("Adds two numbers together") .OpenApiResponse(400, "Some sort of error") //.Serializer<DefaultCaseJsonSerializer>() .Options(options => options .JsonNamingStrategies <DefaultNamingStrategy, SnakeCaseNamingStrategy>() ) ) /*.OpenApiName("HelloWorld")*/ //.Timer<HelloWorldCommand, HelloWorldTimerCommandFactory>("*/5 * * * * *") .Storage("StorageConnectionString", storage => storage .QueueFunction <HelloWorldCommand>("myqueue") ) .ServiceBus("ServiceBusConnectionString", sb => sb .QueueFunction <HelloWorldCommand>("myqueue") .SubscriptionFunction <HelloWorldCommand>("mytopic", "mysub") ) ); }
/// <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.AddNotificationApplication(commandRegistry); }) .Functions(functions => functions .ServiceBus("serviceBusConnectionName", serviceBus => serviceBus .QueueFunction <SendEmailCommand>("sendEmailQueue"))); }
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) => { commandRegistry.Discover <ServerlessConfiguration>(); }) .Functions(functions => functions .HttpRoute("Appreciations", route => route .HttpFunction <GetAppreciationsQuery>(HttpMethod.Get) ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { commandRegistry.Register <GetUsersCommandHandlers>(); }) .Functions(functions => functions .HttpRoute("v1/GetUsers", route => route .HttpFunction <GetUsersCommand>() ) ); }
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) => { 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((sc, r) => { r.Register <SimpleCommandHandler>(); }) .OpenApiEndpoint(openApi => openApi.Title("My API").UserInterface().Version("1.0.0")) .Functions(functions => functions .HttpRoute("api", route => route .HttpFunction <SimpleCommand>() ) .ServiceBus("myconnection", sb => sb.QueueFunction <SimpleCommand>("myqueue")) .Storage("storageconnection", s => s.QueueFunction <SimpleCommand>("myqueue")) .CosmosDb("mycosmos", c => c.ChangeFeedFunction <SimpleCommand>("collection", "database")) .Timer <SimpleCommand>("1 * * * * *") ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => commandRegistry .Register <SendEmailCommandHandler>() .Register <NewUserRegistrationCommandHandler>() ) .Functions(functions => functions .ServiceBus(ServiceBusConnectionName, serviceBus => serviceBus .QueueFunction <SendEmailCommand>(QueueName) .SubscriptionFunction <NewUserRegistrationCommand>(TopicName, SubscriptionName) ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { serviceCollection.AddTransient <IValidator <HelloWorldCommand>, HelloWorldCommandValidator>(); serviceCollection.AddTransient <IStringHasher, StringHasher>(); commandRegistry.Register <HelloWorldCommandHandler>(); }) .AddFluentValidation() .Functions(functions => functions .HttpRoute("/api/v1/HelloWorld", route => route .HttpFunction <HelloWorldCommand>(HttpMethod.Get) ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup(sc => sc .AddMediatR(typeof(FunctionAppConfiguration).Assembly) .AddSingleton <IRepository, Repository>() ) .UseMediatR() .Functions(functions => functions .HttpRoute("todo", route => route .HttpFunction <GetAllToDoItemsQuery>(HttpMethod.Get) .HttpFunction <MarkToDoItemCompleteCommand>("complete", HttpMethod.Put) .HttpFunction <CreateToDoItemCommand>(HttpMethod.Post) ) ); }
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) => { commandRegistry.Discover <FunctionAppConfiguration>(); }) .OutputAuthoredSource(@"c:\wip\outputsource") .Functions(functions => functions .HttpRoute("someroute", route => route .HttpFunction <SimpleHttpRouteCommand>()) .Storage("storageaccount", storage => storage .QueueFunction <StorageQueueCommand>("storagequeuecommandqueue") .BlobFunction <BlobCommand>("blobcommandcontainer/{name}") // TODO: We need to have the compiler insert parameters on the function for everything surrounded in {} - e.g. {name} needs a string parameter of name .BlobFunction <StreamBlobCommand>("streamblobcommandcontainer/{name}") ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { commandRegistry.Register <HelloWorldCommandHandler>(); commandRegistry.Register <AddCommandHandler>(); commandRegistry.Register <CosmosCommandHandler>(); commandRegistry.Register <CosmosDocumentCommandHandler>(); commandRegistry.Register <CosmosDocumentBatchCommandHandler>(); serviceCollection.AddLogging(); }) .OpenApiEndpoint(openApi => openApi .Title("A Simple API") .Version("0.0.0") .UserInterface() ) .OutputAuthoredSource(@"c:\wip\scratch\outputSource") .Functions(functions => functions .HttpRoute("/HelloWorld", route => route .HttpFunction <HelloWorldCommand>("/{name}", AuthorizationTypeEnum.Anonymous, HttpMethod.Get) .OpenApiDescription("Says hello world") .AddHeaderMapping(x => x.HeaderName, "x-header-name") //.ResponseHandler<CustomResponseHandler>() ) .OpenApiDescription("A route description") .CosmosDb("CosmosConnection", cosmos => cosmos .ChangeFeedFunction <CosmosCommand, ExampleCosmosErrorHandler>("Items", "ToDoList", leaseCollectionPrefix: "fn1") //, convertToPascalCase:true) //.ChangeFeedFunction<CosmosDocumentCommand>("Items", "ToDoList") //.ChangeFeedFunction<CosmosDocumentBatchCommand>("Items", "ToDoList", leaseCollectionPrefix:"fn2") ) /*.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}")) ); }
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) ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((services, commandRegistry) => { services.AddApplication(commandRegistry); JsonConvert.DefaultSettings = () => new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }; }) .Authorization(authorization => authorization .AuthorizationDefault(AuthorizationTypeEnum.TokenValidation) .TokenValidator <BearerTokenValidator>() .Claims(claims => claims .MapClaimToCommandProperty <AddConsignmentCommand>( ClaimTypes.NameIdentifier, cmd => cmd.CreatedByUserId) .MapClaimToCommandProperty <AddTrackingCommand>( ClaimTypes.NameIdentifier, cmd => cmd.CreatedByUserId)) ) .AddFluentValidation() .DefaultHttpResponseHandler <HttpResponseHandler>() .Functions(functions => functions .HttpRoute("/api/token", route => route.HttpFunction <GetToken>(AuthorizationTypeEnum.Anonymous, HttpMethod.Post)) .HttpRoute("/api/consignment/v1/add", route => route.HttpFunction <AddConsignmentCommand>(AuthorizationTypeEnum.TokenValidation, HttpMethod.Post)) .Options(options => options.ClaimsPrincipalAuthorization <IsValidUserClaimsAuthorization>()) .HttpRoute("/api/consignment/v1/", route => route.HttpFunction <GetConsignmentQuery>(AuthorizationTypeEnum.Anonymous, HttpMethod.Get)) .HttpRoute("/api/tracking/v1/add", route => route.HttpFunction <AddTrackingCommand>(AuthorizationTypeEnum.TokenValidation, HttpMethod.Post)) .Options(options => options.ClaimsPrincipalAuthorization <IsValidUserClaimsAuthorization>()) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { serviceCollection .AddApplication(commandRegistry) .AddAutoMapper(typeof(SubsystemRegistration)) .Replace(new ServiceDescriptor( typeof(ICommandDispatcher), typeof(CustomDispatcher), ServiceLifetime.Transient)) ; }) .Authorization(authorization => authorization .AuthorizationDefault(AuthorizationTypeEnum.TokenValidation) .AddOpenIdConnectTokenValidator( $"https://{Domain}/.well-known/openid-configuration", Audience ) .Claims(claims => claims .MapClaimToCommandProperty <AddPostCommand>( ClaimTypes.NameIdentifier, cmd => cmd.UserId ) ) ) .AddFluentValidation() .DefaultHttpResponseHandler <HttpResponseHandler>() .Functions(functions => functions .HttpRoute("/api/v1/post", route => route .HttpFunction <AddPostCommand>(HttpMethod.Post) .Options(options => options.ClaimsPrincipalAuthorization <IsApprovedAuthorClaimsAuthorization>()) .HttpFunction <GetPostQuery>( "/{postId}", AuthorizationTypeEnum.Anonymous, HttpMethod.Get) ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { commandRegistry.Discover <ServerlessBlogConfiguration>(); }) .OutputAuthoredSource("d:\\wip\\outputSource") .OpenApiEndpoint(openApi => openApi .Title("Just A Test API") .Servers("http://localhost:7001") .Version("0.0.0") .UserInterface() ) .Functions(functions => functions .HttpRoute("/api/v1/post", route => route .HttpFunction <GetBlogPostQuery>(HttpMethod.Get) ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { serviceCollection.AddValidatorsFromAssembly(typeof(FunctionAppConfiguration).Assembly); commandRegistry.Discover(typeof(FunctionAppConfiguration).Assembly); }) .OpenApiEndpoint(openApi => openApi .Title("My API Title 2.0.0-beta-113") .Version("v2") .UserInterface() .AddValidatorsFromAssembly(typeof(FunctionAppConfiguration).Assembly) .AddXmlComments(Path.Combine(Path.GetDirectoryName(typeof(FunctionAppConfiguration).Assembly.Location), "OpenApi.xml")) ) .AddFluentValidation() .Functions(functions => { functions.RegisterCustomers(); }); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { serviceCollection .AddApplication(commandRegistry) .AddAutoMapper(typeof(SubsystemRegistration)) .Replace(new ServiceDescriptor( typeof(ICommandDispatcher), typeof(CustomDispatcher), ServiceLifetime.Transient)) ; }) .AddFluentValidation() .DefaultHttpResponseHandler <HttpResponseHandler>() .Functions(functions => functions .HttpRoute("/api/v1/post", route => route .HttpFunction <AddPostCommand>(HttpMethod.Post) .HttpFunction <GetPostQuery>("/{postId}", HttpMethod.Get) ) ); }
public void Build(IFunctionHostBuilder builder) { builder .Setup((serviceCollection, commandRegistry) => { commandRegistry.Discover <GetEventByIdHandler>(); serviceCollection.AddServices(); }) .AddFluentValidation() .OpenApiEndpoint(openApi => openApi .Title("A Simple API") .Version("0.0.0") .UserInterface() ) .Functions(functions => functions .HttpRoute("/api/events", route => route .HttpFunction <EventListQuery>(HttpMethod.Get) ) .HttpRoute("/api/events", route => route .HttpFunction <EventQuery>("/{id}", HttpMethod.Get) ) .HttpRoute("/api/events/{id}/attendees", route => route .HttpFunction <EventAttendeeQuery>(HttpMethod.Get) ) .HttpRoute("/api/events/{id}/payments", route => route .HttpFunction <EventPaymentsQuery>(HttpMethod.Get) ) .HttpRoute("/api/events/{id}/pledges", route => route .HttpFunction <EventPledgesQuery>(HttpMethod.Get) ) .HttpRoute("/api/attendees/{id}", route => route .HttpFunction <AttendeeQuery>(HttpMethod.Get) ) ); }