internal static IHandlerBuilder <CommandMessage <TMessage> > LogAuthorizeAndValidate <TMessage, TValidator>(
this IHandlerBuilder <CommandMessage <TMessage> > handleBuilder, TValidator validator)
{
return(handleBuilder
.LogExceptions()
.DenyAnonymous()
.ValidateWith(validator));
}
public static TestRunner Run(IHandlerBuilder handlerBuilder, bool defaults = true)
{
var runner = new TestRunner(defaults);
runner.Host.Handler(handlerBuilder).Start();
return(runner);
}
protected Upstream(ushort port, IHandlerBuilder handler)
{
Host = GenHTTP.Engine.Host.Create()
.Port(port)
.Handler(handler)
.Start();
Port = port;
}
/// <summary>
/// Handles the message and is the last stage in a handler pipeline.
/// </summary>
/// <param name="handlerBuilder">The <see cref="IHandlerBuilder{TMessage}"/>instance.</param>
/// <param name="handler">The handler.</param>
public static void Handle <TMessage>(this IHandlerBuilder <TMessage> handlerBuilder, HandlerSync <TMessage> handler)
where TMessage : class
{
handlerBuilder.Handle((message, _) =>
{
handler(message);
return(Task.FromResult(0));
});
}
internal CoreRouter(IHandlerBuilder content, IEnumerable <IConcernBuilder> concerns, bool development)
{
Content = Concerns.Chain(this, concerns, (p) => content.Build(p));
Template = Placeholders.Template <TemplateModel>(Data.FromResource("Template.html"))
.Build();
ErrorRenderer = Placeholders.Template <ErrorModel>(Data.FromResource(development ? "ErrorStacked.html" : "Error.html"))
.Build();
}
public VirtualHostRouterBuilder Add(string host, IHandlerBuilder handler)
{
if (_Hosts.ContainsKey(host))
{
throw new InvalidOperationException("A host with this name has already been added");
}
_Hosts.Add(host, handler);
return(this);
}
internal static IHandlerBuilder <CommandMessage <TMessage> > DenyAnonymous <TMessage>(
this IHandlerBuilder <CommandMessage <TMessage> > handlerBuilder)
{
return(handlerBuilder.Pipe(next => (message, ct) =>
{
if (message.RequestUser.Identity.IsAuthenticated)
{
throw new InvalidOperationException("Not authenticated");
}
return next(message, ct);
}));
}
public static IHandlerBuilder <T> ConnectionTimeoutRetry <T>(
this IHandlerBuilder <T> handlerBuilder)
where T : class
{
return(handlerBuilder.Pipe(next => (message, ct) =>
{
return Policy.Handle <TimeoutException>()
.RetryForeverAsync(ex =>
{
/* log message, system warning etc */
})
.ExecuteAsync(() => next(message, ct));
}));
}
internal static IHandlerBuilder <TMessage> LogExceptions <TMessage>(this IHandlerBuilder <TMessage> handleBuilder)
{
return(handleBuilder.Pipe(next => async(message, ct) =>
{
try
{
await next(message, ct);
}
catch (Exception ex)
{
//logger.ErrorException("Exception occured while blah blah", ex);
throw;
}
}));
}
internal static IHandlerBuilder <TMessage> PerformanceCounter <TMessage>(this IHandlerBuilder <TMessage> handleBuilder)
{
return(handleBuilder.Pipe(next => async(message, ct) =>
{
var startNew = Stopwatch.StartNew();
try
{
await next(message, ct);
}
finally
{
var elapsed = startNew.ElapsedMilliseconds;
// output perf counter
}
}));
}
private void LoadClient(ServiceProvider serviceProvider)
{
_handlerBuilder = new RomanApp.Controller.Bootstrap().GetBuilder(_serviceProvider);
_handlerBuilder.SQLiteStorage("sqlite")
.Location(Windows.Storage.ApplicationData.Current.LocalFolder.Path)
.Add();
Reedoo.NET.Client.Builder.ClientBuilder builder =
new Reedoo.NET.Client.Builder.ClientBuilder(serviceProvider);
builder.AddAssembly(GetType().Assembly);
builder.NewApp(APP_NAME)
.AddAssembly(GetType().Assembly)
.AddAssembly(typeof(BackInput).Assembly)
.Add();
_uwpClient = builder.BuildUWPClient();
//_uwpClient.CredentialArrived += UWPClient_CredentialArrived;
}
public IHandlerBuilder GetBuilder(ServiceProvider serviceProvider)
{
IHandlerBuilder retval = null;
retval = serviceProvider.GetService <IHandlerBuilder>();
retval.EnableLocalBinding(true)
.Set();
retval.NewApp("RomanApp")
.AddAssembly(GetType().Assembly)
.AddAssembly(typeof(BackInput).Assembly)
.NewRoomDefinition(EventType.Offline).SetHandlerType(typeof(RomanAppRoomHandler)).Add()
.NewRoom().SetId(ROOM_ID).SetRoomType(EventType.Offline).SetName(ROOM_ID).Add()
.Add();
return(retval);
}
public WebsiteRouter(IHandler parent,
IHandlerBuilder content,
IEnumerable <IConcernBuilder> concerns,
IHandlerBuilder scripts,
IHandlerBuilder styles,
IResourceProvider?favicon,
IMenuProvider?menu,
ITheme theme)
{
Parent = parent;
var layout = Layout.Create()
.Add("scripts", scripts)
.Add("styles", styles)
.Add("sitemap.xml", Sitemap.Create())
.Add("robots.txt", BotInstructions.Default().Sitemap())
.Fallback(content);
foreach (var concern in concerns)
{
layout.Add(concern);
}
if (favicon != null)
{
layout.Add("favicon.ico", Download.From(favicon).Type(ContentType.ImageIcon));
}
if (theme.Resources != null)
{
layout.Add("resources", theme.Resources);
}
Handler = layout.Build(this);
Theme = theme;
Menu = menu ?? Websites.Menu.Create((r, _) => GetContent(r)).Build();
var scriptRouter = (ScriptRouter)scripts.Build(this);
var styleRouter = (StyleRouter)styles.Build(this);
Renderer = new WebsiteRenderer(Theme, Menu, scriptRouter, styleRouter);
}
private ClientBuilder LoadClientBuilder(ServiceProvider serviceProvider)
{
ClientBuilder retval = null;
_handlerBuilder = new RomanApp.Controller.Bootstrap().GetBuilder(_serviceProvider);
_handlerBuilder.SQLiteStorage("sqlite")
.Location(Environment.GetFolderPath(Environment.SpecialFolder.Personal))
.Add();
retval = new ClientBuilder(serviceProvider);
retval.AddAssembly(GetType().Assembly);
retval.NewApp(APP_NAME)
.AddAssembly(GetType().Assembly)
.AddAssembly(typeof(BackInput).Assembly)
.Add();
return(retval);
}
public static ICreateHandlerBuilder HandleQuery <TInput, TOutput>(
this IHandlerBuilder <QueryMessage <TInput, TOutput> > handler, Func <TInput, CancellationToken, Task <TOutput> > query)
{
return(handler.Handle(async(message, ct) =>
{
try
{
var result = await query(message.Input, ct);
if (ct.IsCancellationRequested)
{
message.Source.TrySetCanceled();
}
else
{
message.Source.TrySetResult(result);
}
}
catch (Exception ex)
{
message.Source.TrySetException(ex);
}
}));
}
/// <summary>
/// 初始化一个新的默认微信处理程序。
/// </summary>
/// <param name="builder">处理构造者。</param>
public DefaultWeiXinHandler(IHandlerBuilder builder)
{
_builder = builder;
}
public LayoutBuilder Fallback(IHandlerBuilder handler)
{
_Fallback = handler;
return(this);
}
internal static IHandlerBuilder <CommandMessage <TMessage> > ValidateWith <TMessage>(
this IHandlerBuilder <CommandMessage <TMessage> > handlerBuilder, object validator)
{
return(handlerBuilder);
}
public LayoutBuilder Add(string name, IHandlerBuilder handler)
{
Handlers.Add(name, handler);
return(this);
}
internal static IHandlerBuilder <CommandMessage <TMessage> > RequiresClaim <TMessage>(
this IHandlerBuilder <CommandMessage <TMessage> > handlerBuilder,
Func <Claim, bool> claimPredicate)
{
return(handlerBuilder);
}
/// <summary>
/// 初始化一个新的默认微信处理程序。
/// </summary>
/// <param name="builder">处理构造者。</param>
public DefaultHandler(IHandlerBuilder builder, Action <object, EventMsg> registerMiddlewareEventCall = null)
{
_builder = builder;
_registerMiddlewareEventCall = registerMiddlewareEventCall;
}
public GildedRose(IList <Item> items, IHandlerBuilder handlerBuilder)
{
_items = items ?? throw new ArgumentNullException(nameof(items));
_handlerBuilder = handlerBuilder;
}
/// <summary>
/// Sets the logo of the application which will be shown
/// in the upper left corner of rendered web pages.
/// </summary>
/// <param name="provider">A handler which will return a PNG logo to be displayed</param>
/// <example>
/// Logo(Download.FromFile("./images/mylogo.png"))
/// </example>
public AdminLteBuilder Logo(IHandlerBuilder provider)
{
_Logo = provider;
return(this);
}
/// <summary>
/// 使用一个处理中间件。
/// </summary>
/// <typeparam name="T">处理中间件类型。</typeparam>
/// <param name="builder">处理构造者。</param>
/// <param name="args">参数。</param>
/// <returns>处理构造者。</returns>
public static IHandlerBuilder Use <T>(this IHandlerBuilder builder, params object[] args) where T : HandlerMiddleware
{
return(builder.Use((HandlerMiddleware)Activator.CreateInstance(typeof(T)), args));
}
public static Upstream Create(IHandlerBuilder handler)
{
return(new Upstream(TestRunner.NextPort(), handler));
}
public IServerBuilder Handler(IHandlerBuilder handler)
{
_Handler = handler;
return(this);
}
public IServerHost Handler(IHandlerBuilder handler)
{
_Builder.Handler(handler); return(this);
}
/// <summary>
/// 初始化一个新的默认微信处理程序。
/// </summary>
/// <param name="builder">处理构造者。</param>
public DefaultWeiXinHandler(IHandlerBuilder builder)
{
_builder = builder;
}
public WebsiteBuilder Content(IHandlerBuilder content)
{
_Content = content;
return(this);
}
/// <summary>
/// 使用一个处理中间件。
/// </summary>
/// <typeparam name="T">处理中间件类型。</typeparam>
/// <param name="builder">处理构造者。</param>
/// <param name="args">参数。</param>
/// <returns>处理构造者。</returns>
public static IHandlerBuilder Use <T>(this IHandlerBuilder builder, params object[] args) where T : HandlerMiddleware
{
return(builder.Use(typeof(T), args));
}
public VirtualHostRouterBuilder Default(IHandlerBuilder handler)
{
_DefaultRoute = handler;
return(this);
}
