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)
)
);
}