public WeatherController(
IRouteProvider routeProvider,
IEnumerable <IWeatherService> weatherServices)
{
_routeProvider = routeProvider;
_weatherServices = weatherServices.ToList();
}
public RouteManager(IRouteProvider routeProvider, ICacheRepository cacheRepository,
ILogger <RouteManager> logger)
{
_routeProvider = routeProvider;
_cacheRepository = cacheRepository;
_logger = logger;
}
public ObjectSender(HttpClient httpClient, IRouteProvider routes)
{
Ensure.NotNull(httpClient, "httpClient");
Ensure.NotNull(routes, "routes");
this.httpClient = httpClient;
this.routes = routes;
}
public CountriesController(
IRouteProvider routeProvider,
ICountriesService countriesService)
{
_routeProvider = routeProvider;
_countriesService = countriesService;
}
public MembershipService(IRepository <User> users, IRandomProvider randomProvider, IMessageService messageService, IRouteProvider routeProvider, IUserService userService)
{
_users = users;
_randomProvider = randomProvider;
_messageService = messageService;
_routeProvider = routeProvider;
_userService = userService;
}
public GetParameterlessSimple(
IRequestHandler requestHandler,
IRouteProvider routeProvider,
IObjectFactory objectFactory)
{
_requestHandler = requestHandler;
_routeProvider = routeProvider;
_objectFactory = objectFactory;
}
public RouteWorker(
IRouteProvider routeProvider,
ICompleteMomentProvider completeMomentProvider,
IRouteReplicator routeReplicator)
{
_routeProvider = routeProvider;
_completeMomentProvider = completeMomentProvider;
_routeReplicator = routeReplicator;
}
public CommandBase(IRouteProvider routeProvider, params byte[] routeCode)
{
if (routeCode == null || routeProvider.RouteLength != routeCode.Length)
{
throw new ArgumentException("路由与路由规则不匹配！");
}
RouteProvider = routeProvider;
RouteCode = routeCode;
}
/// <summary>
/// Retorune le premier domain qui match avec l'url
/// </summary>
/// <param name="url"></param>
/// <param name="data"></param>
/// <param name="routeProvider"> </param>
/// <param name="cultureId"> </param>
/// <returns></returns>
private static async Task <Route> LoadRouteAsync(string url, IDictionary <string, string> data,
IRouteProvider routeProvider, Dictionary <string, string> domainDatas, string siteId,
ILogger <RouteManager> logger)
{
var routes = routeProvider.GetRoutes(domainDatas);
if (routes == null)
{
return(null);
}
// Home page
if (string.IsNullOrEmpty(url))
{
var metadatas = await routeProvider.GetRootMetadataAsync(siteId);
return(RouteResult(data, routeProvider, domainDatas, metadatas, logger));
}
foreach (var route in routes)
{
var path = route.Path;
// Cas particulier pour la racine du site
if (string.IsNullOrEmpty(path))
{
if (string.IsNullOrEmpty(url))
{
return(route);
}
continue;
}
if (string.IsNullOrEmpty(url))
{
continue;
}
if (CheckRoute(url, data, route, path))
{
return(route);
}
}
var redirectRoutes = await routeProvider.GetRedirectRoutesAsync(siteId);
foreach (var route in redirectRoutes)
{
var path = route.Path;
if (CheckRoute(url, data, route, path))
{
return(route);
}
}
return(null);
}
public ConfiguredModule(ILogger logger, IRouteProvider provider, ITemplateEngine engine)
{
_logger = logger;
_engine = engine;
var routes = provider.GetRoutes();
foreach (var route in routes)
{
RouteBuilder builder;
switch (route.Type)
{
case RequestType.Get:
builder = Get;
break;
case RequestType.Post:
builder = Post;
break;
case RequestType.Put:
builder = Put;
break;
case RequestType.Delete:
builder = Delete;
break;
case RequestType.Head:
builder = Head;
break;
case RequestType.Options:
builder = Options;
break;
case RequestType.Patch:
builder = Patch;
break;
default:
builder = null;
break;
}
if (builder != null)
{
builder[route.Path] = _ =>
{
Func <Response> function = () => GetResponse(route, Context);
return(ExecuteWithDelay(function, route.CurrentDelayInMilliseconds));
};
}
}
}
public void Init()
{
_sitecoreSettingsFacade = new Mock <ISitecoreSettingsFacade>();
_sitecoreDatbaseFacade = new Mock <ISitecoreDatabaseFacade>();
_linkManagerFacade = new Mock <ILinkManagerFacade>();
_routeProvider = new RouteProvider(_sitecoreSettingsFacade.Object,
_sitecoreDatbaseFacade.Object,
_linkManagerFacade.Object);
}
public JourneyBuilder(IAirlineProvider airlineProvider, IAirportProvider airportProvider, IRouteProvider routeProvider,
string sourceAirportAlias, string destinationAirportAlias, CancellationToken cancellationToken = default(CancellationToken))
{
_airlineProvider = airlineProvider ?? throw new ArgumentNullException(nameof(airlineProvider));
_airportProvider = airportProvider ?? throw new ArgumentNullException(nameof(airportProvider));
_routeProvider = routeProvider ?? throw new ArgumentNullException(nameof(routeProvider));
_sourceAirportAlias = sourceAirportAlias ?? throw new ArgumentNullException(nameof(sourceAirportAlias));
_destinationAirportAlias = destinationAirportAlias ?? throw new ArgumentNullException(nameof(destinationAirportAlias));
_cancellationToken = cancellationToken;
}
public ArticleController(IRepository <Article, Guid> repository,
IRouteProvider routerProvider,
IArticleModelBuilder <ArticleViewModel> articleModelBuilder,
IModelBuilder <CommentViewModel> commentModelBuilder)
{
_repository = repository;
_routeProvider = routerProvider;
_commenModelBuilder = commentModelBuilder;
_articleModelBuilder = articleModelBuilder;
}
public DefaultLinkFactory(
IRouteProvider <bool> routeProvider,
IPagingLinkBuilder pagingLinkBuilder,
ISortingLinkBuilder sortingLinkBuilder,
IAuthorisationPolicy authorisationPolicy)
{
_routeProvider = routeProvider;
_pagingLinkBuilder = pagingLinkBuilder;
_sortingLinkBuilder = sortingLinkBuilder;
_authorisationPolicy = authorisationPolicy;
}
public AddSiteCommand(IDataFactory dataFactorySource, IDataFactory dataFactoryDestination,
UserService userService, IEmailService emailService, CacheProvider cacheProvider, SiteUserService siteUserService, BusinessModuleFactory businessModuleFactory, IRouteManager routeManager, IRouteProvider routeProvider)
{
_dataFactorySource = dataFactorySource;
_dataFactoryDestination = dataFactoryDestination;
_userService = userService;
_emailService = emailService;
_cacheProvider = cacheProvider;
_siteUserService = siteUserService;
_businessModuleFactory = businessModuleFactory;
_routeManager = routeManager;
_routeProvider = routeProvider;
}
/// <summary>
/// Creates a new instance with a <paramref name="baseUrl"/> and a inner <paramref name="routeTable"/>.
/// </summary>
/// <param name="baseUrl">A base URL prepended to relative URLs.</param>
/// <param name="routeTable">An inner route provider.</param>
public RelativeRouteProvider(string baseUrl, IRouteProvider routeTable)
{
Ensure.NotNullOrEmpty(baseUrl, "baseUrl");
Ensure.NotNull(routeTable, "routeTable");
if (!Uri.TryCreate(baseUrl, UriKind.Absolute, out Uri url))
{
throw Ensure.Exception.ArgumentOutOfRange("baseUrl", "Base URL must be valid and absolute URL.");
}
this.baseUrl = baseUrl;
this.routeTable = routeTable;
}
public AssessmentsService(IRepository <AssessmentRequest> assessmentRequests, IRepository <AssessmentSubmission> assessmentSubmissions, IMessageService messageService, ITaskRunner taskRunner, ILecturesService lecturesService, IApplicationSettings applicationSettings, IRepository <CourseSubscription> subscriptions, IRouteProvider routeProvider, ICertificatesService certificatesService, IRepository <Course> courses)
{
_assessmentRequests = assessmentRequests;
_assessmentSubmissions = assessmentSubmissions;
_messageService = messageService;
_taskRunner = taskRunner;
_lecturesService = lecturesService;
_applicationSettings = applicationSettings;
_subscriptions = subscriptions;
_routeProvider = routeProvider;
_certificatesService = certificatesService;
_courses = courses;
}
public SubscriptionsService(IRepository <User> users, IRepository <CourseSubscription> courseSubscriptions, IRepository <Course> courses, ICoursesService coursesService, IUserService usersService, ILecturesService lectures, IAssessmentsService assessments, IMessageService messageService, IRepository <Payment> payments, IRouteProvider routeProvider, IOrdersService ordersService)
{
_users = users;
_courseSubscriptions = courseSubscriptions;
_courses = courses;
_coursesService = coursesService;
_usersService = usersService;
_lectures = lectures;
_assessments = assessments;
_messageService = messageService;
_payments = payments;
_routeProvider = routeProvider;
_ordersService = ordersService;
}
/// <summary>
/// 初始化服务器
/// </summary>
/// <param name="routeProvider">规则提供程序</param>
/// <param name="port">端口</param>
/// <returns>服务器对象</returns>
public static SocketServer InitServer(IRouteProvider routeProvider, int port)
{
SocketServer appServer = new SocketServer(routeProvider);
if (!appServer.Setup(port)) //Setup with listening port
{
throw new Exception("Failed to setup!");
}
if (!appServer.Start())
{
throw new Exception("Failed to start!");
}
return(appServer);
}
public ConfiguredModule(IRouteProvider provider, ITemplateEngine engine)
{
_engine = engine;
var routes = provider.GetRoutes();
foreach (var route in routes)
{
switch (route.Type)
{
case RequestType.Get:
Get[route.Template] = _ =>
{
Func <Response> function = () => GetResponse(route, Context);
return(ExecuteWithDelay(function, route.CurrentDelayInMilliseconds));
};
break;
case RequestType.Post:
Post[route.Template] = _ =>
{
Func <Response> function = () => GetResponse(route, Context);
return(ExecuteWithDelay(function, route.CurrentDelayInMilliseconds));
};
break;
case RequestType.Put:
Put[route.Template] = _ =>
{
Func <Response> function = () => GetResponse(route, Context);
return(ExecuteWithDelay(function, route.CurrentDelayInMilliseconds));
};
break;
case RequestType.Delete:
Put[route.Template] = _ =>
{
Func <Response> function = () => GetResponse(route, Context);
return(ExecuteWithDelay(function, route.CurrentDelayInMilliseconds));
};
break;
default:
break;
}
}
}
private static Route RouteResult(IDictionary <string, string> data, IRouteProvider routeProvider,
Dictionary <string, string> domainDatas,
IDictionary <string, string> metadatas, ILogger <RouteManager> logger)
{
if (metadatas != null)
{
foreach (var defaultValue in metadatas)
{
data.Add(defaultValue);
}
Route routeResult;
GetRoutePath(routeProvider, data, domainDatas, logger, out routeResult);
return(routeResult);
}
throw new Exception("cache problem");
}
public RouteContainer(IRouteProvider routeProvider)
{
if (routeProvider == null)
{
throw new ArgumentNullException("The route provider cannot be null. Please specify a route provider.");
}
this.routeProvider = routeProvider;
IEnumerable<RouteItem> routes = this.routeProvider.GetRoutes();
if (routes == null)
{
return;
}
foreach (RouteItem route in routes)
{
this.MapRoute(route);
}
}
public SocketClient(IRouteProvider routeProvider, params Assembly[] cmdAssemblies)
{
RouteProvider = routeProvider;
//加载处理程序
var commandAssemblies = cmdAssemblies;
foreach (var assembly in commandAssemblies)
{
try
{
lock (ResponseHandlers)
{
ResponseHandlers.AddRange(assembly.GetImplementedObjectsByInterface <ISocketPackageHandler>());
}
}
catch (Exception exc)
{
throw new Exception(string.Format("加载程序集失败，程序集： {0}!", assembly.FullName), exc);
}
}
}
public RouteContainer(IRouteProvider routeProvider)
{
if (routeProvider == null)
{
throw new ArgumentNullException("The route provider cannot be null. Please specify a route provider.");
}
this.routeProvider = routeProvider;
IEnumerable <RouteItem> routes = this.routeProvider.GetRoutes();
if (routes == null)
{
return;
}
foreach (RouteItem route in routes)
{
this.MapRoute(route);
}
}
/// <summary>
/// Retourne la première route qui match
/// </summary>
/// <returns></returns>
private static string GetRoutePath(IRouteProvider cache, IDictionary <string, string> datas,
IDictionary <string, string> domainDatas, ILogger <RouteManager> logger, out Route routeResult)
{
if (!datas.ContainsKey("action") || !datas.ContainsKey("controller"))
{
logger.LogWarning("no action or controller found");
routeResult = null;
return(string.Empty);
}
var action = datas["action"];
var controller = datas["controller"];
foreach (var route in cache.GetRoutes(domainDatas))
{
var isCorrect = route.Controller == controller && route.Action == action;
var isCorrect1 = string.IsNullOrEmpty(route.Controller) && string.IsNullOrEmpty(route.Action);
var isCorrect2 = string.IsNullOrEmpty(route.Action) && route.Controller == controller;
// TODO : finir tous les tests
if (isCorrect || isCorrect1 || isCorrect2)
{
// On génère le chemin
var path = GetPath(route.Path, datas, route.DefaultValues);
// C'est que le chemin n'est pas le bon
if (!string.IsNullOrEmpty(path) && path.Contains("{"))
{
continue;
}
routeResult = route;
return(path);
}
}
routeResult = null;
return(string.Empty);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
ILogService logService,
IRouteProvider routeProvider,
IServiceProvider serviceProvider)
{
loggerFactory.AddLog(Configuration.GetSection("Logging"), logService);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
//app.UseMiddleware<CustomErrorPagesMiddleware>();
app.UseStaticFiles();
app.UseAuthentication();
app.UseMvc(routeProvider.RegisterRoutes);
}
/// <summary>
/// Retorune le premier domain qui match avec l'url
/// </summary>
/// <param name="url"></param>
/// <param name="data"></param>
/// <param name="routeProvider"></param>
/// <param name="culture"></param>
/// <param name="siteId"></param>
/// <returns></returns>
private static async Task <LoadDomainResult> LoadDomainAsync(string url, IDictionary <string, string> data,
IRouteProvider routeProvider, ILogger <RouteManager> _logger)
{
var loadDomainResult = new LoadDomainResult();
if (string.IsNullOrEmpty(url))
{
return(loadDomainResult);
}
if (data == null)
{
return(loadDomainResult);
}
if (routeProvider.Domains == null)
{
return(loadDomainResult);
}
var siteId = string.Empty;
foreach (var domain in routeProvider.Domains)
{
siteId = string.Empty;
data.Clear();
if (!string.IsNullOrEmpty(domain.Regex) && RegExMatch(domain.Regex, url))
{
var domainRegex = CreateRegexDomain(domain.Path);
var domainMatch = domainRegex.Match(url);
if (domainMatch.Success)
{
GetDatas(data, domainRegex, domainMatch);
#region On récupère le site
if (!string.IsNullOrEmpty(domain.SiteId))
{
siteId = domain.SiteId;
}
else if (data.Count > 0)
{
siteId = await routeProvider.GetSiteIdAsync(data, domain.DomainMasterId);
}
if (string.IsNullOrEmpty(siteId))
{
continue;
}
#endregion
loadDomainResult.SiteId = siteId;
loadDomainResult.Domain = domain;
return(loadDomainResult);
}
_logger.LogWarning("Erreur dans la configuration du domainId :" + domain.Id);
}
}
return(loadDomainResult);
}
protected override void RegisterCustomRoutes(RouteCollection routes, IRouteProvider routeProvider)
{
// Add additional routes with this syntax
// routeProvider.MapRoute(routes, null, "Test", new { Controller = "Test", Action = "Index" }, true);
}
public RouteProviderCached(Cache.SimpleMemoryCache <string, IList <Route> > cache, IRouteProvider routeProvider)
: base(cache, (alias, cancellationToken) => { return(routeProvider.Get(alias, cancellationToken)); })
{
}
/// <summary>
/// 初始化过滤器（默认会话信息头部为路由码+4位数据长度）
/// </summary>
/// <param name="routeProvider">路由提供程序</param>
public RouteReceiveFilter(IRouteProvider routeProvider)
: base(routeProvider.RouteLength + 4)
{
RouteProvider = routeProvider;
}
public LoggingRouteProvider(IRouteProvider routeProvider, ILogger logger)
{
_routeProvider = routeProvider;
_logger = logger;
}
protected override void RegisterCustomRoutes(RouteCollection routes, IRouteProvider routeProvider)
{
// Add additional routes with this syntax
// routeProvider.MapRoute(routes, null, "Test", new { Controller = "Test", Action = "Index" }, true);
}
