public async Task <IEnumerable <WebHookFilter> > Get()
{
IWebHookFilterManager filterManager = Configuration.DependencyResolver.GetFilterManager();
IDictionary <string, WebHookFilter> filters = await filterManager.GetAllWebHookFiltersAsync();
return(filters.Values);
}
/// <summary>
/// For testing purposes
/// </summary>
internal static void Reset()
{
_filterManager = null;
_manager = null;
_filterProviders = null;
_store = null;
}
public WebHookRegistrationsController(IJsonFieldsSerializer jsonFieldsSerializer,
IAclService aclService,
ICustomerService customerService,
IStoreMappingService storeMappingService,
IStoreService storeService,
IDiscountService discountService,
ICustomerActivityService customerActivityService,
ILocalizationService localizationService,
IPictureService pictureService,
IStoreContext storeContext,
IWebHookService webHookService,
IHttpContextAccessor httpContextAccessor,
IClientStore clientStore)
: base(jsonFieldsSerializer,
aclService, customerService,
storeMappingService,
storeService,
discountService,
customerActivityService,
localizationService,
pictureService)
{
_storeContext = storeContext;
_manager = webHookService.GetWebHookManager();
_store = webHookService.GetWebHookStore();
_filterManager = webHookService.GetWebHookFilterManager();
_httpContextAccessor = httpContextAccessor;
_clientStore = clientStore;
}
public async Task <IEnumerable <WebHookFilter> > Get()
{
IWebHookFilterManager filterManager = HttpContext.RequestServices.GetFilterManager();
IDictionary <string, WebHookFilter> filters = await filterManager.GetAllWebHookFiltersAsync();
return(filters.Values);
}
public WebHookRegistrationsControllerTests()
{
IPrincipal principal = new ClaimsPrincipal();
_managerMock = new Mock <IWebHookManager>();
_storeMock = new Mock <MemoryWebHookStore> {
CallBase = true
};
_userMock = new Mock <IWebHookUser>();
_userMock.Setup(u => u.GetUserIdAsync(principal))
.ReturnsAsync(TestUser);
_filterProviderMock = new Mock <IWebHookFilterProvider>();
_filterProviderMock.Setup(p => p.GetFiltersAsync())
.ReturnsAsync(new Collection <WebHookFilter> {
new WebHookFilter {
Name = FilterName
}
});
_filterManager = new WebHookFilterManager(new[]
{
new WildcardWebHookFilterProvider(),
_filterProviderMock.Object
});
_registrar = new Mock <IWebHookRegistrar>();
var services = new Dictionary <Type, object>
{
{ typeof(IWebHookManager), _managerMock.Object },
{ typeof(IWebHookStore), _storeMock.Object },
{ typeof(IWebHookUser), _userMock.Object },
{ typeof(IWebHookFilterManager), _filterManager },
{ typeof(IWebHookRegistrar), _registrar.Object }
};
_config = HttpConfigurationMock.Create(services);
_config.Routes.Add(WebHookRouteNames.FiltersGetAction, new HttpRoute());
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, Address);
request.SetConfiguration(_config);
HttpRequestContext requestContext = new HttpRequestContext()
{
Configuration = _config,
Principal = principal,
Url = new UrlHelper(request),
};
_controllerContext = new HttpControllerContext()
{
Configuration = _config,
Request = new HttpRequestMessage(),
RequestContext = requestContext,
};
_controller = new WebHookRegistrationsControllerMock();
_controller.Initialize(_controllerContext);
}
/// <summary>
/// For testing purposes
/// </summary>
internal static void Reset()
{
_filterManager = null;
_store = null;
_sender = null;
_manager = null;
_registrationsManager = null;
_user = null;
}
public WebHookRegistrationsControllerTests()
{
_resolverMock = new Mock <IDependencyResolver>();
_managerMock = new Mock <IWebHookManager>();
_resolverMock.Setup(r => r.GetService(typeof(IWebHookManager)))
.Returns(_managerMock.Object)
.Verifiable();
_store = new MemoryWebHookStore();
_resolverMock.Setup(r => r.GetService(typeof(IWebHookStore)))
.Returns(_store)
.Verifiable();
_user = new WebHookUser();
_resolverMock.Setup(r => r.GetService(typeof(IWebHookUser)))
.Returns(_user)
.Verifiable();
_filterProviderMock = new Mock <IWebHookFilterProvider>();
_filterManager = new WebHookFilterManager(new[]
{
new WildcardWebHookFilterProvider(),
_filterProviderMock.Object
});
_resolverMock.Setup(r => r.GetService(typeof(IWebHookFilterManager)))
.Returns(_filterManager)
.Verifiable();
_config = new HttpConfiguration();
_config.DependencyResolver = _resolverMock.Object;
ClaimsIdentity identity = new ClaimsIdentity();
Claim claim = new Claim(ClaimTypes.Name, TestUser);
identity.AddClaim(claim);
IPrincipal principal = new ClaimsPrincipal(identity);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, Address);
request.SetConfiguration(_config);
HttpRequestContext requestContext = new HttpRequestContext()
{
Configuration = _config,
Principal = principal,
Url = new UrlHelper(request),
};
_controllerContext = new HttpControllerContext()
{
Configuration = _config,
Request = new HttpRequestMessage(),
RequestContext = requestContext,
};
_controller = new WebHookRegistrationsControllerMock();
_controller.Initialize(_controllerContext);
}
/// <summary>
/// Ensure that the provided <paramref name="webHook"/> only has registered filters.
/// </summary>
protected virtual async Task VerifyFilters(WebHook webHook)
{
if (webHook == null)
{
throw new ArgumentNullException(nameof(webHook));
}
// If there are no filters then add our wildcard filter.
if (webHook.Filters.Count == 0)
{
webHook.Filters.Add(WildcardWebHookFilterProvider.Name);
await InvokeRegistrars(webHook);
return;
}
IWebHookFilterManager filterManager = Configuration.DependencyResolver.GetFilterManager();
IDictionary <string, WebHookFilter> filters = await filterManager.GetAllWebHookFiltersAsync();
HashSet <string> normalizedFilters = new HashSet <string>();
List <string> invalidFilters = new List <string>();
foreach (string filter in webHook.Filters)
{
WebHookFilter hookFilter;
if (filters.TryGetValue(filter, out hookFilter))
{
normalizedFilters.Add(hookFilter.Name);
}
else
{
invalidFilters.Add(filter);
}
}
if (invalidFilters.Count > 0)
{
string invalidFiltersMsg = string.Join(", ", invalidFilters);
string link = Url.Link(WebHookRouteNames.FiltersGetAction, routeValues: null);
string msg = string.Format(CultureInfo.CurrentCulture, CustomApiResources.RegistrationController_InvalidFilters, invalidFiltersMsg, link);
Configuration.DependencyResolver.GetLogger().Info(msg);
HttpResponseMessage response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, msg);
throw new HttpResponseException(response);
}
else
{
webHook.Filters.Clear();
foreach (string filter in normalizedFilters)
{
webHook.Filters.Add(filter);
}
}
await InvokeRegistrars(webHook);
}
public WebHookRegistrationsControllerTests()
{
IPrincipal principal = new ClaimsPrincipal();
_managerMock = new Mock<IWebHookManager>();
_storeMock = new Mock<MemoryWebHookStore> { CallBase = true };
_userMock = new Mock<IWebHookUser>();
_userMock.Setup(u => u.GetUserIdAsync(principal))
.ReturnsAsync(TestUser);
_filterProviderMock = new Mock<IWebHookFilterProvider>();
_filterProviderMock.Setup(p => p.GetFiltersAsync())
.ReturnsAsync(new Collection<WebHookFilter> { new WebHookFilter { Name = FilterName } });
_filterManager = new WebHookFilterManager(new[]
{
new WildcardWebHookFilterProvider(),
_filterProviderMock.Object
});
_registrarMock = new Mock<IWebHookRegistrar>();
_idValidatorMock = new Mock<IWebHookIdValidator>();
var services = new Dictionary<Type, object>
{
{ typeof(IWebHookManager), _managerMock.Object },
{ typeof(IWebHookStore), _storeMock.Object },
{ typeof(IWebHookUser), _userMock.Object },
{ typeof(IWebHookFilterManager), _filterManager },
{ typeof(IWebHookRegistrar), _registrarMock.Object },
{ typeof(IWebHookIdValidator), _idValidatorMock.Object },
};
_config = HttpConfigurationMock.Create(services);
_config.Routes.Add(WebHookRouteNames.FiltersGetAction, new HttpRoute());
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, Address);
request.SetConfiguration(_config);
HttpRequestContext requestContext = new HttpRequestContext()
{
Configuration = _config,
Principal = principal,
Url = new UrlHelper(request),
};
_controllerContext = new HttpControllerContext()
{
Configuration = _config,
Request = new HttpRequestMessage(),
RequestContext = requestContext,
};
_controller = new WebHookRegistrationsControllerMock();
_controller.Initialize(_controllerContext);
}
public IWebHookFilterManager GetWebHookFilterManager()
{
if (_webHookFilterManager == null)
{
var filterProviders = new List <IWebHookFilterProvider>();
filterProviders.Add(new FilterProvider());
_webHookFilterManager = new WebHookFilterManager(filterProviders);
}
return(_webHookFilterManager);
}
public WebHookRegistrationsControllerTests()
{
_resolverMock = new Mock<IDependencyResolver>();
_managerMock = new Mock<IWebHookManager>();
_resolverMock.Setup(r => r.GetService(typeof(IWebHookManager)))
.Returns(_managerMock.Object)
.Verifiable();
_store = new MemoryWebHookStore();
_resolverMock.Setup(r => r.GetService(typeof(IWebHookStore)))
.Returns(_store)
.Verifiable();
_user = new WebHookUser();
_resolverMock.Setup(r => r.GetService(typeof(IWebHookUser)))
.Returns(_user)
.Verifiable();
_filterProviderMock = new Mock<IWebHookFilterProvider>();
_filterManager = new WebHookFilterManager(new[]
{
new WildcardWebHookFilterProvider(),
_filterProviderMock.Object
});
_resolverMock.Setup(r => r.GetService(typeof(IWebHookFilterManager)))
.Returns(_filterManager)
.Verifiable();
_config = new HttpConfiguration();
_config.DependencyResolver = _resolverMock.Object;
ClaimsIdentity identity = new ClaimsIdentity();
Claim claim = new Claim(ClaimTypes.Name, TestUser);
identity.AddClaim(claim);
IPrincipal principal = new ClaimsPrincipal(identity);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, Address);
request.SetConfiguration(_config);
HttpRequestContext requestContext = new HttpRequestContext()
{
Configuration = _config,
Principal = principal,
Url = new UrlHelper(request),
};
_controllerContext = new HttpControllerContext()
{
Configuration = _config,
Request = new HttpRequestMessage(),
RequestContext = requestContext,
};
_controller = new WebHookRegistrationsControllerMock();
_controller.Initialize(_controllerContext);
}
/// <summary>
/// Gets an <see cref="IWebHookFilterManager"/> implementation registered with the Dependency Injection engine
/// or a default implementation if none are registered.
/// </summary>
/// <param name="services">The <see cref="IDependencyScope"/> implementation.</param>
/// <returns>The registered <see cref="IWebHookFilterManager"/> instance or a default implementation if none are registered.</returns>
public static IWebHookFilterManager GetFilterManager(this IDependencyScope services)
{
IWebHookFilterManager filterManager = services.GetService <IWebHookFilterManager>();
if (filterManager == null)
{
IEnumerable <IWebHookFilterProvider> filterProviders = services.GetFilterProviders();
filterManager = CustomServices.GetFilterManager(filterProviders);
}
return(filterManager);
}
public async Task GetAllWebHookFilters_GetsAllFilters(int providerCount, int expectedFilterCount)
{
// Arrange
IWebHookFilterManager manager = CreateWebHookFilterManager(providerCount);
// Act
IDictionary <string, WebHookFilter> actual = await manager.GetAllWebHookFiltersAsync();
// Assert
Assert.Equal(expectedFilterCount, actual.Count);
}
public void GetFilterManager_ReturnsDefaultInstance_IfNoneRegistered()
{
// Arrange
WebHooksConfig.Initialize(_config);
// Act
IWebHookFilterManager actual = _resolverMock.Object.GetFilterManager();
// Assert
Assert.IsType <WebHookFilterManager>(actual);
}
public WebHookFiltersController(
IJsonFieldsSerializer jsonFieldsSerializer,
IAclService aclService,
IUserService userService,
ITenantMappingService tenantMappingService,
ITenantService tenantService,
IUserActivityService userActivityService,
IWebHookService webHookService)
: base(jsonFieldsSerializer, aclService, userService, tenantMappingService, tenantService, userActivityService)
{
_filterManager = webHookService.GetWebHookFilterManager();
}
public void GetFilterManager_ReturnsSameInstance_IfNoneRegistered()
{
// Arrange
_config.InitializeCustomWebHooks();
// Act
IWebHookFilterManager actual1 = _resolverMock.Object.GetFilterManager();
IWebHookFilterManager actual2 = _resolverMock.Object.GetFilterManager();
// Assert
Assert.Same(actual1, actual2);
}
public void GetFilterManager_ReturnsSingletonInstance()
{
// Arrange
List <IWebHookFilterProvider> providers = new List <IWebHookFilterProvider>();
// Act
IWebHookFilterManager actual1 = CustomServices.GetFilterManager(providers);
IWebHookFilterManager actual2 = CustomServices.GetFilterManager(providers);
// Assert
Assert.Same(actual1, actual2);
}
public static IWebHookRegistrationsManager GetRegistrationsManager(this IDependencyScope services)
{
IWebHookRegistrationsManager registrationsManager = services.GetService <IWebHookRegistrationsManager>();
if (registrationsManager == null)
{
IWebHookManager manager = services.GetManager();
IWebHookStore store = services.GetStore();
IWebHookFilterManager filterManager = services.GetFilterManager();
IWebHookUser userManager = services.GetUser();
registrationsManager = CustomServices.GetRegistrationsManager(manager, store, filterManager, userManager);
}
return(registrationsManager);
}
public void GetFilterManager_ReturnsDependencyInstance_IfRegistered()
{
// Arrange
Mock <IWebHookFilterManager> instanceMock = new Mock <IWebHookFilterManager>();
_resolverMock.Setup(r => r.GetService(typeof(IWebHookFilterManager)))
.Returns(instanceMock.Object)
.Verifiable();
// Act
IWebHookFilterManager actual = _resolverMock.Object.GetFilterManager();
// Assert
Assert.Same(instanceMock.Object, actual);
instanceMock.Verify();
}
public WebHookRegistrationsController(
IJsonFieldsSerializer jsonFieldsSerializer,
IAclService aclService,
IUserService userService,
ITenantMappingService tenantMappingService,
ITenantService tenantService,
IUserActivityService userActivityService,
IWebHookService webHookService,
IHttpContextAccessor httpContextAccessor)
: base(jsonFieldsSerializer, aclService, userService, tenantMappingService, tenantService, userActivityService)
{
_manager = webHookService.GetWebHookManager();
_store = webHookService.GetWebHookStore();
_filterManager = webHookService.GetWebHookFilterManager();
_httpContextAccessor = httpContextAccessor;
}
public WebHookFiltersControllerTests()
{
WildcardWebHookFilterProvider provider = new WildcardWebHookFilterProvider();
_filterManager = new WebHookFilterManager(new[] { provider });
_resolverMock = new Mock<IDependencyResolver>();
_resolverMock.Setup(r => r.GetService(typeof(IWebHookFilterManager)))
.Returns(_filterManager)
.Verifiable();
_config = new HttpConfiguration();
_config.DependencyResolver = _resolverMock.Object;
HttpControllerContext controllerContext = new HttpControllerContext()
{
Configuration = _config,
Request = new HttpRequestMessage(),
};
_controller = new WebHookFiltersController();
_controller.ControllerContext = controllerContext;
}
public WebHookFiltersController(IJsonFieldsSerializer jsonFieldsSerializer,
IAclService aclService,
ICustomerService customerService,
IStoreMappingService storeMappingService,
IStoreService storeService,
IDiscountService discountService,
ICustomerActivityService customerActivityService,
ILocalizationService localizationService,
IPictureService pictureService,
IWebHookService webHookService) :
base(jsonFieldsSerializer,
aclService,
customerService,
storeMappingService,
storeService,
discountService,
customerActivityService,
localizationService,
pictureService)
{
_filterManager = webHookService.GetWebHookFilterManager();
}
/// <summary>
/// Initializes a new instance of the <see cref="WebHookRegistrationsManager"/> class with default
/// settings.
/// </summary>
/// <param name="manager">The current <see cref="IWebHookManager"/>.</param>
/// <param name="store">The current <see cref="IWebHookStore"/>.</param>
/// <param name="filterManager">The current <see cref="IWebHookFilterManager"/>.</param>
/// <param name="userManager">The current <see cref="IWebHookUser"/>.</param>
public WebHookRegistrationsManager(IWebHookManager manager, IWebHookStore store, IWebHookFilterManager filterManager, IWebHookUser userManager)
{
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
if (store == null)
{
throw new ArgumentNullException(nameof(store));
}
if (filterManager == null)
{
throw new ArgumentNullException(nameof(filterManager));
}
if (userManager == null)
{
throw new ArgumentNullException(nameof(userManager));
}
_manager = manager;
_store = store;
_filterManager = filterManager;
_userManager = userManager;
}
public WebHookFiltersControllerTests()
{
WildcardWebHookFilterProvider provider = new WildcardWebHookFilterProvider();
_filterManager = new WebHookFilterManager(new[] { provider });
_resolverMock = new Mock <IDependencyResolver>();
_resolverMock.Setup(r => r.GetService(typeof(IWebHookFilterManager)))
.Returns(_filterManager)
.Verifiable();
_config = new HttpConfiguration();
_config.DependencyResolver = _resolverMock.Object;
HttpControllerContext controllerContext = new HttpControllerContext()
{
Configuration = _config,
Request = new HttpRequestMessage(),
};
_controller = new WebHookFiltersController();
_controller.ControllerContext = controllerContext;
}
/// <summary>
/// For testing purposes
/// </summary>
internal static void Reset()
{
_filterManager = null;
_filterProviders = null;
_store = null;
_sender = null;
_manager = null;
_user = null;
}
/// <inheritdoc />
public WebHookFiltersController(IWebHookFilterManager filterManager)
{
_filterManager = filterManager;
}
public static IWebHookRegistrationsManager GetRegistrationsManager(IWebHookManager manager, IWebHookStore store, IWebHookFilterManager filterManager, IWebHookUser userManager)
{
if (_registrationsManager != null)
{
return(_registrationsManager);
}
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
if (store == null)
{
throw new ArgumentNullException(nameof(store));
}
if (filterManager == null)
{
throw new ArgumentNullException(nameof(filterManager));
}
if (userManager == null)
{
throw new ArgumentNullException(nameof(userManager));
}
IWebHookRegistrationsManager instance = new WebHookRegistrationsManager(manager, store, filterManager, userManager);
Interlocked.CompareExchange(ref _registrationsManager, instance, null);
return(_registrationsManager);
}
