public DefaultLinksHandlerContextFactory(IRouteMap routeMap, ILinkAuthorizationService authService, IActionContextAccessor actionAccessor, ILoggerFactory loggerFactory)
{
this.routeMap = routeMap;
this.authService = authService;
this.actionContext = actionAccessor.ActionContext;
this.loggerFactory = loggerFactory;
}
public LinksAuthorizationTestCase(ILinkAuthorizationService underTest, ClaimsPrincipal user, IRouteMap routeMap, Mock <IAuthorizationService> authServiceMock)
{
this.UnderTest = underTest;
this.User = user;
this.routeMap = routeMap;
this.AuthorizationServiceMock = authServiceMock;
}
public override void Create(IRouteMap routeMap, IDependencyResolver resolver)
{
foreach (var eventType in Types)
{
routeMap[Route].AddPublishedEvent(eventType, 0, EndpointResolver);
}
}
protected CargoCarrier(IRouteMap routeMap, ISupplier supplier)
{
_routeMap = routeMap ?? throw new ArgumentNullException(nameof(routeMap));
_supplier = supplier ?? throw new ArgumentNullException(nameof(supplier));
_route = routeMap.FromLocation(supplier);
}
public TestCaseBuilder WithMockRouteMap(Action <Mock <IRouteMap> > configureRouteMap = null)
{
var mockRouteMap = new Mock <IRouteMap>();
configureRouteMap?.Invoke(mockRouteMap);
this.routeMap = mockRouteMap.Object;
return(this);
}
/// <inheritdoc cref="IDescriptor{TSubject}"/>
public void Create(IRouteMap routeMap, IDependencyResolver resolver)
{
routeMap[m_Route].ProcessingGroup.ConcurrencyLevel = m_ThreadCount;
if (m_QueueCapacity != null)
{
routeMap[m_Route].ProcessingGroup.QueueCapacity = m_QueueCapacity.Value;
}
}
public TestCaseBuilder WithTestRouteMap(Action <TestRouteMap> configureRouteMap = null)
{
var testRouteMap = new TestRouteMap();
configureRouteMap?.Invoke(testRouteMap);
this.routeMap = testRouteMap;
return(this);
}
public override void Create(IRouteMap routeMap, IDependencyResolver resolver)
{
foreach (var type in m_Types)
{
routeMap[Route].AddSubscribedEvent(
type,
0,
m_BoundedContext,
EndpointResolver,
// Set exclusive for projections - only projections can subscribe to the events besides sagas
typeof(TRegistration) != typeof(ISagaRegistration));
}
}
public override void Create(IRouteMap routeMap, IDependencyResolver resolver)
{
foreach (var type in m_CommandsTypes)
{
if (LowestPriority > 0)
{
for (uint priority = 1; priority <= LowestPriority; priority++)
{
routeMap[Route].AddPublishedCommand(type, priority, m_BoundedContext, EndpointResolver);
}
}
else
{
routeMap[Route].AddPublishedCommand(type, 0, m_BoundedContext, EndpointResolver);
}
}
}
public DefaultLinksService(
IOptions <LinksOptions> options,
ILogger <DefaultLinksService> logger,
ILinksHandlerContextFactory contextFactory,
ILinksPolicyProvider policyProvider,
IEnumerable <ILinksHandler> handlers,
IRouteMap routeMap,
ILinksEvaluator evaluator)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (contextFactory == null)
{
throw new ArgumentNullException(nameof(contextFactory));
}
if (policyProvider == null)
{
throw new ArgumentNullException(nameof(policyProvider));
}
if (handlers == null)
{
throw new ArgumentNullException(nameof(handlers));
}
if (routeMap == null)
{
throw new ArgumentNullException(nameof(routeMap));
}
if (evaluator == null)
{
throw new ArgumentNullException(nameof(evaluator));
}
this.options = options.Value;
this.logger = logger;
this.contextFactory = contextFactory;
this.policyProvider = policyProvider;
this.handlers = handlers.ToArray();
this.routeMap = routeMap;
this.evaluator = evaluator;
}
public override void Create(IRouteMap routeMap, IDependencyResolver resolver)
{
foreach (var type in Types)
{
if (LowestPriority > 0)
{
for (uint priority = 1; priority <= LowestPriority; priority++)
{
routeMap[Route].AddSubscribedCommand(type, priority, EndpointResolver);
}
}
else
{
routeMap[Route].AddSubscribedCommand(type, 0, EndpointResolver);
}
}
}
public LinksHandlerContext(
IEnumerable <ILinksRequirement> requirements,
IRouteMap routeMap,
ILinkAuthorizationService authService,
ILogger <LinksHandlerContext> logger,
ActionContext actionContext,
object resource)
{
if (requirements == null)
{
throw new ArgumentNullException(nameof(requirements));
}
if (routeMap == null)
{
throw new ArgumentNullException(nameof(routeMap));
}
if (authService == null)
{
throw new ArgumentNullException(nameof(authService));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
this.Requirements = requirements;
this.RouteMap = routeMap;
this.ActionContext = actionContext;
this.Resource = resource;
this.Logger = logger;
this.authService = authService;
this.pendingRequirements = new HashSet <ILinksRequirement>(requirements);
}
public Truck(IRouteMap routeMap, IFactory factory) : base(routeMap, factory)
{
}
public abstract void Process(IRouteMap routeMap, CqrsEngine cqrsEngine);
public abstract void Create(IRouteMap routeMap, IDependencyResolver resolver);
public override void Process(IRouteMap routeMap, CqrsEngine cqrsEngine)
{
EndpointResolver.SetFallbackResolver(cqrsEngine.EndpointResolver);
}
public RouteProvider(IRouteMap map)
{
_map = map;
}
public TestLinksHandlerContextFactory(IRouteMap routeMap, ILinkAuthorizationService authService, ActionContext actionContext)
{
this.routeMap = routeMap;
this.authService = authService;
this.actionContext = actionContext;
}
/// <inheritdoc cref="IDescriptor{TSubject}"/>
public void Process(IRouteMap routeMap, CqrsEngine cqrsEngine)
{
}
public Ship(IRouteMap routeMap, IPort port) : base(routeMap, port)
{
}
