public RegistrationFactory(
ITypesProvider typesProvider,
IInstanceProvidingMethodGenerator methodGenerator)
{
_typesProvider = typesProvider;
_methodGenerator = methodGenerator;
}
public HandlersProvidersTests()
{
var typesProviderMock = new Mock <ITypesProvider>();
typesProviderMock.Setup(x => x.Types).Returns(new Type[]
{ typeof(HPTestCommand), typeof(HPTestQuery), typeof(HPTestCommandHandler), typeof(HPTestQueryHandler) });
_typesProvider = typesProviderMock.Object;
}
public void Init(ITypesProvider typesProvider)
{
IHandlerRegistry handlerRegistry = typesProvider.Resolve <IHandlerRegistry>();
handlerRegistry.RegisterHandler <GetDeviceDefinitionsQuery, GetDeviceDefinitionsQueryHandler>();
handlerRegistry.RegisterHandler <UpdateDeviceDefinitionCommand, UpdateDeviceDefinitionCommandHandler>();
handlerRegistry.RegisterHandler <GetStoreSnapshotQuery, GetStoreSnapshotQueryHandler>();
handlerRegistry.RegisterHandler <UploadSnapshotCommand, UploadSnapshotCommandHandler>();
}
public CommandNamesProvider(ITypesProvider typesProvider)
{
if (typesProvider == null)
{
throw new ArgumentNullException(nameof(typesProvider));
}
this.typesProvider = typesProvider;
}
public ServiceDescriptorsBuilder AddTypesProvider(ITypesProvider typesProvider)
{
if (typesProvider == null)
{
throw new ArgumentNullException(nameof(typesProvider));
}
_typesProviders.Add(typesProvider);
return(this);
}
public ServiceDescriptorsBuilder AddTypesProvider(ITypesProvider typesProvider)
{
if (typesProvider == null)
{
throw new ArgumentNullException(nameof(typesProvider));
}
_typesProviders.Add(typesProvider);
return this;
}
public SeedCommandRunner(
ICommandNamesProvider commandNamesProvider,
ITypesProvider typesProvider,
Func <Type, IDbSeeder> seederFactory)
{
if (commandNamesProvider == null)
{
throw new ArgumentNullException(nameof(commandNamesProvider));
}
if (typesProvider == null)
{
throw new ArgumentNullException(nameof(typesProvider));
}
if (seederFactory == null)
{
throw new ArgumentNullException(nameof(seederFactory));
}
this.commandNamesProvider = commandNamesProvider;
this.typesProvider = typesProvider;
this.seederFactory = seederFactory;
}
/// <summary>
/// Add types of the assembly of a given object to a given ITypesProvider
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="object"></param>
/// <returns>
/// a new ITypesProvider with original types and types of the assembly of the given object
/// </returns>
public static ITypesProvider AddTypesOfSameAssembly(this ITypesProvider typeProvider, object @object)
{
return(typeProvider.Add(@object.GetTypesFromSameAssembly()));
}
/// <summary>
/// Add types of the assembly of a given type to a given ITypesProvider
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="type"></param>
/// <returns>
/// a new ITypesProvider with original types and types of the assembly of the given type
/// </returns>
public static ITypesProvider AddTypesOfSameAssembly(this ITypesProvider typeProvider, Type type)
{
return(typeProvider.Add(type.GetTypesFromSameAssembly()));
}
/// <summary>
/// Add assembly types to a given ITypesProvider
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="assembly"></param>
/// <returns>
/// a new ITypesProvider with original types and types from the given assembly
/// </returns>
public static ITypesProvider AddTypesFrom(this ITypesProvider typeProvider, Assembly assembly)
{
return(typeProvider.Add(assembly.GetAllTypes()));
}
/// <summary>
/// Filter ITypesProvider returning only types in a given namespace
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="value">
/// namespace name
/// </param>
/// <returns>
/// a new ITypesProvider with types in the given namespace
/// </returns>
public static ITypesProvider InNamespace(this ITypesProvider typeProvider, string value)
{
return(new TypesProvider(typeProvider.Types.Where(t => t.Namespace == value)));
}
/// <summary>
/// Filter ITypesProvider returning only types implementing a given base type
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <typeparam name="T">
/// type to filter
/// </typeparam>
/// <param name="typeProvider"></param>
/// <returns>
/// a new ITypesProvider with types deriving from given type
/// </returns>
public static ITypesProvider Implementing <T>(this ITypesProvider typeProvider)
{
var type = typeof(T);
return(new TypesProvider(typeProvider.Types.Where(t => type != t && type.IsAssignableFrom(t))));
}
/// <summary>
/// Create a new ITypesProvider without the given types
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="types">
/// types to be removed from result
/// </param>
/// <returns>
/// a new ITypesProvider not containing the given types
/// </returns>
public static ITypesProvider Except(this ITypesProvider typeProvider, params Type[] types)
{
return(new TypesProvider(typeProvider.Types.Except(types)));
}
public HandlerRegistry(ITypesProvider typesProvider)
{
_typesProvider = typesProvider;
}
public RegistriesInitializer(ITypesProvider typesProvider)
{
_typesProvider = typesProvider;
}
/// <summary>
/// Add types of the two ITypesProvider
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="types"></param>
/// <returns>
/// a new ITypesProvider containing both types
/// </returns>
public static ITypesProvider Add(this ITypesProvider typeProvider, params Type[] types)
{
return(new TypesProvider(typeProvider.Types.Concat(types)));
}
/// <summary>
/// Filter ITypesProvider types based on a given condition
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="filter">
/// type filter: if type matches the criteria it will be removed from result
/// </param>
/// <returns>
/// a new ITypesProvider containing only type of given ITypesProvider corresponding
/// that do not match the filter
/// </returns>
public static ITypesProvider Except(this ITypesProvider typeProvider, Func <Type, bool> filter)
{
return(new TypesProvider(typeProvider.Types.Where(t => !filter(t))));
}
public TypeScriptGenerator(TypeScriptGenerationOptions options, ICustomTypeGenerator customTypeGenerator, ITypesProvider typesProvider)
{
Options = options ?? throw new ArgumentNullException(nameof(options));
TypesProvider = typesProvider ?? throw new ArgumentNullException(nameof(typesProvider));
this.customTypeGenerator = customTypeGenerator ?? throw new ArgumentNullException(nameof(customTypeGenerator));
rootTypes = typesProvider?.GetRootTypes() ?? throw new ArgumentNullException(nameof(typesProvider));
typeUnitFactory = new DefaultTypeScriptGeneratorOutput();
typeDeclarations = new Dictionary <ITypeInfo, ITypeBuildingContext>();
}
/// <summary>
/// Register all the types provided by typeProvider using the given convention
/// </summary>
/// <param name="conventionRouter">
/// Convention router
/// </param>
/// <param name="typeProvider">
/// type provider
/// </param>
/// <returns>
/// the corresponding convention router
/// </returns>
public static IConventionRouter Register(this IConventionRouter conventionRouter, ITypesProvider typeProvider)
{
return(conventionRouter.Register(typeProvider.Types.Distinct()));
}
/// <summary>
/// Filter ITypesProvider returning only types in a given namespace or in a child namespace
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="value">
/// namespace name
/// </param>
/// <returns>
/// a new ITypesProvider with types in the given namespace
/// </returns>
public static ITypesProvider InParentNamespace(this ITypesProvider typeProvider, string value)
{
var childNamespaceStart = $"{value}.";
return(new TypesProvider(typeProvider.Types.Where(t => t.Namespace == value || t.Namespace?.StartsWith(childNamespaceStart) == true)));
}
/// <summary>
/// Filter ITypesProvider returning only types with name ending by given value
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="value">
/// string filter
/// </param>
/// <returns>
/// a new ITypesProvider with types which names ends by given value
/// </returns>
public static ITypesProvider WithNameEndingWith(this ITypesProvider typeProvider, string value)
{
return(new TypesProvider(typeProvider.Types.Where(t => t.Name.EndsWith(value))));
}
/// <summary>
/// Filter ITypesProvider returning only types in a given namespace or in a child namespace
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typeProvider"></param>
/// <param name="type">
/// namespace name
/// </param>
/// <returns>
/// a new ITypesProvider with types in the given namespace
/// </returns>
public static ITypesProvider InParentNamespaceOf(this ITypesProvider typeProvider, Type type)
{
var @namespace = type.Namespace;
return(typeProvider.InParentNamespace(@namespace));
}
/// <summary>
/// Add types of two ITypesProvider
/// <seealso cref="ITypesProvider"/>
/// </summary>
/// <param name="typesProvider"></param>
/// <param name="typesProvider2"></param>
/// <returns>
/// a new ITypesProvider with types of both typeProvider
/// </returns>
public static ITypesProvider Add(this ITypesProvider typesProvider, ITypesProvider typesProvider2)
{
return(new TypesProvider(typesProvider.Types.Concat(typesProvider2.Types)));
}
public ServiceRegistrator(ITypesProvider typesProvider)
{
_typesProvider = typesProvider;
}
