8664272182

Committed 12 Apr 2024 03:08PM UTC coverage: 59.163%. Remained the same

Build # 8664272182

Build Type

push

github

Committed by

pwelter34

Commit Message

Update Directory.Build.props

Run Details

226 of 426 branches covered (53.05%)

Branch coverage included in aggregate %.

552 of 889 relevant lines covered (62.09%)

20.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/MediatR.CommandQuery.Cosmos/DomainServiceExtensions.cs

using Cosmos.Abstracts;

using FluentValidation;

using MediatR.CommandQuery.Behaviors;
using MediatR.CommandQuery.Commands;
using MediatR.CommandQuery.Cosmos.Handlers;
using MediatR.CommandQuery.Definitions;
using MediatR.CommandQuery.Extensions;
using MediatR.CommandQuery.Queries;
using MediatR.CommandQuery.Services;
using MediatR.Registration;

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;

namespace MediatR.CommandQuery.Cosmos;

public static class DomainServiceExtensions
{
    public static IServiceCollection AddEntityQueries<TRepository, TEntity, TReadModel>(this IServiceCollection services)
        where TRepository : ICosmosRepository<TEntity>
        where TEntity : class, IHaveIdentifier<string>, new()
        where TReadModel : class
    {
        if (services is null)
            throw new System.ArgumentNullException(nameof(services));

        // standard queries
        services.TryAddTransient<IRequestHandler<EntityIdentifierQuery<string, TReadModel>, TReadModel>, EntityIdentifierQueryHandler<TRepository, TEntity, TReadModel>>();
        services.TryAddTransient<IRequestHandler<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>, EntityIdentifiersQueryHandler<TRepository, TEntity, TReadModel>>();
        services.TryAddTransient<IRequestHandler<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, EntityPagedQueryHandler<TRepository, TEntity, TReadModel>>();
        services.TryAddTransient<IRequestHandler<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, EntitySelectQueryHandler<TRepository, TEntity, TReadModel>>();

        // pipeline registration, run in order registered
        bool supportsTenant = typeof(TReadModel).Implements<IHaveTenant<string>>();
        if (supportsTenant)
        {
            services.AddTransient<IPipelineBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, TenantPagedQueryBehavior<string, TReadModel>>();
            services.AddTransient<IPipelineBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, TenantSelectQueryBehavior<string, TReadModel>>();
        }

        bool supportsDeleted = typeof(TReadModel).Implements<ITrackDeleted>();
        if (supportsDeleted)
        {
            services.AddTransient<IPipelineBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, DeletedPagedQueryBehavior<TReadModel>>();
            services.AddTransient<IPipelineBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, DeletedSelectQueryBehavior<TReadModel>>();
        }

        return services;
    }

    public static IServiceCollection AddEntityQueryMemoryCache<TRepository, TEntity, TReadModel>(this IServiceCollection services)
        where TRepository : ICosmosRepository<TEntity>
        where TEntity : class, IHaveIdentifier<string>, new()
    {
        if (services is null)
            throw new System.ArgumentNullException(nameof(services));

        services.AddTransient<IPipelineBehavior<EntityIdentifierQuery<string, TReadModel>, TReadModel>, MemoryCacheQueryBehavior<EntityIdentifierQuery<string, TReadModel>, TReadModel>>();
        services.AddTransient<IPipelineBehavior<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>, MemoryCacheQueryBehavior<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>>();
        services.AddTransient<IPipelineBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, MemoryCacheQueryBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>>();
        services.AddTransient<IPipelineBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, MemoryCacheQueryBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>>();

        return services;
    }

    public static IServiceCollection AddEntityQueryDistributedCache<TRepository, TEntity, TReadModel>(this IServiceCollection services)
        where TRepository : ICosmosRepository<TEntity>
        where TEntity : class, IHaveIdentifier<string>, new()
    {
        if (services is null)
            throw new System.ArgumentNullException(nameof(services));

        services.AddTransient<IPipelineBehavior<EntityIdentifierQuery<string, TReadModel>, TReadModel>, DistributedCacheQueryBehavior<EntityIdentifierQuery<string, TReadModel>, TReadModel>>();
        services.AddTransient<IPipelineBehavior<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>, DistributedCacheQueryBehavior<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>>();
        services.AddTransient<IPipelineBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, DistributedCacheQueryBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>>();
        services.AddTransient<IPipelineBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, DistributedCacheQueryBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>>();

        return services;
    }


    public static IServiceCollection AddEntityCommands<TRepository, TEntity, TReadModel, TCreateModel, TUpdateModel>(this IServiceCollection services)
        where TRepository : ICosmosRepository<TEntity>
        where TEntity : class, IHaveIdentifier<string>, new()
        where TCreateModel : class
        where TUpdateModel : class
    {
        if (services is null)
            throw new System.ArgumentNullException(nameof(services));

        services.TryAddSingleton<IPrincipalReader, PrincipalReader>();

        services
            .AddEntityCreateCommand<TRepository, TEntity, TReadModel, TCreateModel>()
            .AddEntityUpdateCommand<TRepository, TEntity, TReadModel, TUpdateModel>()
            .AddEntityUpsertCommand<TRepository, TEntity, TReadModel, TUpdateModel>()
            .AddEntityPatchCommand<TRepository, TEntity, TReadModel>()
            .AddEntityDeleteCommand<TRepository, TEntity, TReadModel>();

        return services;
    }


    public static IServiceCollection AddEntityCreateCommand<TRepository, TEntity, TReadModel, TCreateModel>(this IServiceCollection services)
        where TRepository : ICosmosRepository<TEntity>
        where TEntity : class, IHaveIdentifier<string>, new()
        where TCreateModel : class
    {
        if (services is null)
            throw new System.ArgumentNullException(nameof(services));

        // standard crud commands
        services.TryAddTransient<IRequestHandler<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, EntityCreateCommandHandler<TRepository, TEntity, TCreateModel, TReadModel>>();

        // pipeline registration, run in order registered
        var createType = typeof(TCreateModel);
        bool supportsTenant = createType.Implements<IHaveTenant<string>>();
        if (supportsTenant)
        {
            services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, TenantDefaultCommandBehavior<string, TCreateModel, TReadModel>>();
            services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, TenantAuthenticateCommandBehavior<string, TCreateModel, TReadModel>>();
        }

        bool supportsTracking = createType.Implements<ITrackCreated>();
        if (supportsTracking)
            services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, TrackChangeCommandBehavior<TCreateModel, TReadModel>>();

        services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, ValidateEntityModelCommandBehavior<TCreateModel, TReadModel>>();
        services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TCreateModel, TReadModel>>();

        return services;
    }

    public static IServiceCollection AddEntityUpdateCommand<TRepository, TEntity, TReadModel, TUpdateModel>(this IServiceCollection services)
        where TRepository : ICosmosRepository<TEntity>
        where TEntity : class, IHaveIdentifier<string>, new()
        where TUpdateModel : class
    {
        if (services is null)
            throw new System.ArgumentNullException(nameof(services));

        // allow query for update models
        services.TryAddTransient<IRequestHandler<EntityIdentifierQuery<string, TUpdateModel>, TUpdateModel>, EntityIdentifierQueryHandler<TRepository, TEntity, TUpdateModel>>();
        services.TryAddTransient<IRequestHandler<EntityIdentifiersQuery<string, TUpdateModel>, IReadOnlyCollection<TUpdateModel>>, EntityIdentifiersQueryHandler<TRepository, TEntity, TUpdateModel>>();

        // standard crud commands
        services.TryAddTransient<IRequestHandler<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, EntityUpdateCommandHandler<TRepository, TEntity, TUpdateModel, TReadModel>>();

        // pipeline registration, run in order registered
        var updateType = typeof(TUpdateModel);
        bool supportsTenant = updateType.Implements<IHaveTenant<string>>();
        if (supportsTenant)
        {
            services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, TenantDefaultCommandBehavior<string, TUpdateModel, TReadModel>>();
            services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, TenantAuthenticateCommandBehavior<string, TUpdateModel, TReadModel>>();
        }

        bool supportsTracking = updateType.Implements<ITrackUpdated>();
        if (supportsTracking)
            services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, TrackChangeCommandBehavior<TUpdateModel, TReadModel>>();

        services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, ValidateEntityModelCommandBehavior<TUpdateModel, TReadModel>>();
        services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TUpdateModel, TReadModel>>();

        return services;
    }

    public static IServiceCollection AddEntityUpsertCommand<TRepository, TEntity, TReadModel, TUpdateModel>(this IServiceCollection services)
        where TRepository : ICosmosRepository<TEntity>
        where TEntity : class, IHaveIdentifier<string>, new()
        where TUpdateModel : class
    {
        if (services is null)
            throw new System.ArgumentNullException(nameof(services));

        // standard crud commands
        services.TryAddTransient<IRequestHandler<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, EntityUpsertCommandHandler<TRepository, TEntity, TUpdateModel, TReadModel>>();

        // pipeline registration, run in order registered
        var updateType = typeof(TUpdateModel);
        bool supportsTenant = updateType.Implements<IHaveTenant<string>>();
        if (supportsTenant)
        {
            services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, TenantDefaultCommandBehavior<string, TUpdateModel, TReadModel>>();
            services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, TenantAuthenticateCommandBehavior<string, TUpdateModel, TReadModel>>();
        }

        bool supportsTracking = updateType.Implements<ITrackUpdated>();
        if (supportsTracking)
            services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, TrackChangeCommandBehavior<TUpdateModel, TReadModel>>();

        services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, ValidateEntityModelCommandBehavior<TUpdateModel, TReadModel>>();
        services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TUpdateModel, TReadModel>>();

        return services;
    }

    public static IServiceCollection AddEntityPatchCommand<TRepository, TEntity, TReadModel>(this IServiceCollection services)
        where TRepository : ICosmosRepository<TEntity>
        where TEntity : class, IHaveIdentifier<string>, new()
    {
        if (services is null)
            throw new System.ArgumentNullException(nameof(services));

        // standard crud commands
        services.TryAddTransient<IRequestHandler<EntityPatchCommand<string, TReadModel>, TReadModel>, EntityPatchCommandHandler<TRepository, TEntity, TReadModel>>();

        // pipeline registration, run in order registered
        services.AddTransient<IPipelineBehavior<EntityPatchCommand<string, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TEntity, TReadModel>>();

        return services;
    }

    public static IServiceCollection AddEntityDeleteCommand<TRepository, TEntity, TReadModel>(this IServiceCollection services)
        where TRepository : ICosmosRepository<TEntity>
        where TEntity : class, IHaveIdentifier<string>, new()
    {
        if (services is null)
            throw new System.ArgumentNullException(nameof(services));

        // standard crud commands
        services.TryAddTransient<IRequestHandler<EntityDeleteCommand<string, TReadModel>, TReadModel>, EntityDeleteCommandHandler<TRepository, TEntity, TReadModel>>();

        // pipeline registration, run in order registered
        services.AddTransient<IPipelineBehavior<EntityDeleteCommand<string, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TEntity, TReadModel>>();

        return services;
    }
}

1	using Cosmos.Abstracts;
2
3	using FluentValidation;
4
5	using MediatR.CommandQuery.Behaviors;
6	using MediatR.CommandQuery.Commands;
7	using MediatR.CommandQuery.Cosmos.Handlers;
8	using MediatR.CommandQuery.Definitions;
9	using MediatR.CommandQuery.Extensions;
10	using MediatR.CommandQuery.Queries;
11	using MediatR.CommandQuery.Services;
12	using MediatR.Registration;
13
14	using Microsoft.Extensions.DependencyInjection;
15	using Microsoft.Extensions.DependencyInjection.Extensions;
16
17	namespace MediatR.CommandQuery.Cosmos;
18
19	public static class DomainServiceExtensions
20	{
21	public static IServiceCollection AddEntityQueries<TRepository, TEntity, TReadModel>(this IServiceCollection services)
22	where TRepository : ICosmosRepository<TEntity>
23	where TEntity : class, IHaveIdentifier<string>, new()
24	where TReadModel : class
25	{
26	if (services is null)	×
27	throw new System.ArgumentNullException(nameof(services));	×
28
29	// standard queries
30	services.TryAddTransient<IRequestHandler<EntityIdentifierQuery<string, TReadModel>, TReadModel>, EntityIdentifierQueryHandler<TRepository, TEntity, TReadModel>>();	×
31	services.TryAddTransient<IRequestHandler<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>, EntityIdentifiersQueryHandler<TRepository, TEntity, TReadModel>>();	×
32	services.TryAddTransient<IRequestHandler<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, EntityPagedQueryHandler<TRepository, TEntity, TReadModel>>();	×
33	services.TryAddTransient<IRequestHandler<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, EntitySelectQueryHandler<TRepository, TEntity, TReadModel>>();	×
34
35	// pipeline registration, run in order registered
36	bool supportsTenant = typeof(TReadModel).Implements<IHaveTenant<string>>();	×
37	if (supportsTenant)	×
38	{
39	services.AddTransient<IPipelineBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, TenantPagedQueryBehavior<string, TReadModel>>();	×
40	services.AddTransient<IPipelineBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, TenantSelectQueryBehavior<string, TReadModel>>();	×
41	}
42
43	bool supportsDeleted = typeof(TReadModel).Implements<ITrackDeleted>();	×
44	if (supportsDeleted)	×
45	{
46	services.AddTransient<IPipelineBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, DeletedPagedQueryBehavior<TReadModel>>();	×
47	services.AddTransient<IPipelineBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, DeletedSelectQueryBehavior<TReadModel>>();	×
48	}
49
50	return services;	×
51	}
52
53	public static IServiceCollection AddEntityQueryMemoryCache<TRepository, TEntity, TReadModel>(this IServiceCollection services)
54	where TRepository : ICosmosRepository<TEntity>
55	where TEntity : class, IHaveIdentifier<string>, new()
56	{
57	if (services is null)	×
58	throw new System.ArgumentNullException(nameof(services));	×
59
60	services.AddTransient<IPipelineBehavior<EntityIdentifierQuery<string, TReadModel>, TReadModel>, MemoryCacheQueryBehavior<EntityIdentifierQuery<string, TReadModel>, TReadModel>>();	×
61	services.AddTransient<IPipelineBehavior<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>, MemoryCacheQueryBehavior<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>>();	×
62	services.AddTransient<IPipelineBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, MemoryCacheQueryBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>>();	×
63	services.AddTransient<IPipelineBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, MemoryCacheQueryBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>>();	×
64
65	return services;	×
66	}
67
68	public static IServiceCollection AddEntityQueryDistributedCache<TRepository, TEntity, TReadModel>(this IServiceCollection services)
69	where TRepository : ICosmosRepository<TEntity>
70	where TEntity : class, IHaveIdentifier<string>, new()
71	{
72	if (services is null)	×
73	throw new System.ArgumentNullException(nameof(services));	×
74
75	services.AddTransient<IPipelineBehavior<EntityIdentifierQuery<string, TReadModel>, TReadModel>, DistributedCacheQueryBehavior<EntityIdentifierQuery<string, TReadModel>, TReadModel>>();	×
76	services.AddTransient<IPipelineBehavior<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>, DistributedCacheQueryBehavior<EntityIdentifiersQuery<string, TReadModel>, IReadOnlyCollection<TReadModel>>>();	×
77	services.AddTransient<IPipelineBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>, DistributedCacheQueryBehavior<EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>>();	×
78	services.AddTransient<IPipelineBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>, DistributedCacheQueryBehavior<EntitySelectQuery<TReadModel>, IReadOnlyCollection<TReadModel>>>();	×
79
80	return services;	×
81	}
82
83
84	public static IServiceCollection AddEntityCommands<TRepository, TEntity, TReadModel, TCreateModel, TUpdateModel>(this IServiceCollection services)
85	where TRepository : ICosmosRepository<TEntity>
86	where TEntity : class, IHaveIdentifier<string>, new()
87	where TCreateModel : class
88	where TUpdateModel : class
89	{
90	if (services is null)	×
91	throw new System.ArgumentNullException(nameof(services));	×
92
93	services.TryAddSingleton<IPrincipalReader, PrincipalReader>();	×
94
95	services	×
96	.AddEntityCreateCommand<TRepository, TEntity, TReadModel, TCreateModel>()	×
97	.AddEntityUpdateCommand<TRepository, TEntity, TReadModel, TUpdateModel>()	×
98	.AddEntityUpsertCommand<TRepository, TEntity, TReadModel, TUpdateModel>()	×
99	.AddEntityPatchCommand<TRepository, TEntity, TReadModel>()	×
100	.AddEntityDeleteCommand<TRepository, TEntity, TReadModel>();	×
101
102	return services;	×
103	}
104
105
106	public static IServiceCollection AddEntityCreateCommand<TRepository, TEntity, TReadModel, TCreateModel>(this IServiceCollection services)
107	where TRepository : ICosmosRepository<TEntity>
108	where TEntity : class, IHaveIdentifier<string>, new()
109	where TCreateModel : class
110	{
111	if (services is null)	×
112	throw new System.ArgumentNullException(nameof(services));	×
113
114	// standard crud commands
115	services.TryAddTransient<IRequestHandler<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, EntityCreateCommandHandler<TRepository, TEntity, TCreateModel, TReadModel>>();	×
116
117	// pipeline registration, run in order registered
118	var createType = typeof(TCreateModel);	×
119	bool supportsTenant = createType.Implements<IHaveTenant<string>>();	×
120	if (supportsTenant)	×
121	{
122	services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, TenantDefaultCommandBehavior<string, TCreateModel, TReadModel>>();	×
123	services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, TenantAuthenticateCommandBehavior<string, TCreateModel, TReadModel>>();	×
124	}
125
126	bool supportsTracking = createType.Implements<ITrackCreated>();	×
127	if (supportsTracking)	×
128	services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, TrackChangeCommandBehavior<TCreateModel, TReadModel>>();	×
129
130	services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, ValidateEntityModelCommandBehavior<TCreateModel, TReadModel>>();	×
131	services.AddTransient<IPipelineBehavior<EntityCreateCommand<TCreateModel, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TCreateModel, TReadModel>>();	×
132
133	return services;	×
134	}
135
136	public static IServiceCollection AddEntityUpdateCommand<TRepository, TEntity, TReadModel, TUpdateModel>(this IServiceCollection services)
137	where TRepository : ICosmosRepository<TEntity>
138	where TEntity : class, IHaveIdentifier<string>, new()
139	where TUpdateModel : class
140	{
141	if (services is null)	×
142	throw new System.ArgumentNullException(nameof(services));	×
143
144	// allow query for update models
145	services.TryAddTransient<IRequestHandler<EntityIdentifierQuery<string, TUpdateModel>, TUpdateModel>, EntityIdentifierQueryHandler<TRepository, TEntity, TUpdateModel>>();	×
146	services.TryAddTransient<IRequestHandler<EntityIdentifiersQuery<string, TUpdateModel>, IReadOnlyCollection<TUpdateModel>>, EntityIdentifiersQueryHandler<TRepository, TEntity, TUpdateModel>>();	×
147
148	// standard crud commands
149	services.TryAddTransient<IRequestHandler<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, EntityUpdateCommandHandler<TRepository, TEntity, TUpdateModel, TReadModel>>();	×
150
151	// pipeline registration, run in order registered
152	var updateType = typeof(TUpdateModel);	×
153	bool supportsTenant = updateType.Implements<IHaveTenant<string>>();	×
154	if (supportsTenant)	×
155	{
156	services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, TenantDefaultCommandBehavior<string, TUpdateModel, TReadModel>>();	×
157	services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, TenantAuthenticateCommandBehavior<string, TUpdateModel, TReadModel>>();	×
158	}
159
160	bool supportsTracking = updateType.Implements<ITrackUpdated>();	×
161	if (supportsTracking)	×
162	services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, TrackChangeCommandBehavior<TUpdateModel, TReadModel>>();	×
163
164	services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, ValidateEntityModelCommandBehavior<TUpdateModel, TReadModel>>();	×
165	services.AddTransient<IPipelineBehavior<EntityUpdateCommand<string, TUpdateModel, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TUpdateModel, TReadModel>>();	×
166
167	return services;	×
168	}
169
170	public static IServiceCollection AddEntityUpsertCommand<TRepository, TEntity, TReadModel, TUpdateModel>(this IServiceCollection services)
171	where TRepository : ICosmosRepository<TEntity>
172	where TEntity : class, IHaveIdentifier<string>, new()
173	where TUpdateModel : class
174	{
175	if (services is null)	×
176	throw new System.ArgumentNullException(nameof(services));	×
177
178	// standard crud commands
179	services.TryAddTransient<IRequestHandler<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, EntityUpsertCommandHandler<TRepository, TEntity, TUpdateModel, TReadModel>>();	×
180
181	// pipeline registration, run in order registered
182	var updateType = typeof(TUpdateModel);	×
183	bool supportsTenant = updateType.Implements<IHaveTenant<string>>();	×
184	if (supportsTenant)	×
185	{
186	services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, TenantDefaultCommandBehavior<string, TUpdateModel, TReadModel>>();	×
187	services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, TenantAuthenticateCommandBehavior<string, TUpdateModel, TReadModel>>();	×
188	}
189
190	bool supportsTracking = updateType.Implements<ITrackUpdated>();	×
191	if (supportsTracking)	×
192	services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, TrackChangeCommandBehavior<TUpdateModel, TReadModel>>();	×
193
194	services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, ValidateEntityModelCommandBehavior<TUpdateModel, TReadModel>>();	×
195	services.AddTransient<IPipelineBehavior<EntityUpsertCommand<string, TUpdateModel, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TUpdateModel, TReadModel>>();	×
196
197	return services;	×
198	}
199
200	public static IServiceCollection AddEntityPatchCommand<TRepository, TEntity, TReadModel>(this IServiceCollection services)
201	where TRepository : ICosmosRepository<TEntity>
202	where TEntity : class, IHaveIdentifier<string>, new()
203	{
204	if (services is null)	×
205	throw new System.ArgumentNullException(nameof(services));	×
206
207	// standard crud commands
208	services.TryAddTransient<IRequestHandler<EntityPatchCommand<string, TReadModel>, TReadModel>, EntityPatchCommandHandler<TRepository, TEntity, TReadModel>>();	×
209
210	// pipeline registration, run in order registered
211	services.AddTransient<IPipelineBehavior<EntityPatchCommand<string, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TEntity, TReadModel>>();	×
212
213	return services;	×
214	}
215
216	public static IServiceCollection AddEntityDeleteCommand<TRepository, TEntity, TReadModel>(this IServiceCollection services)
217	where TRepository : ICosmosRepository<TEntity>
218	where TEntity : class, IHaveIdentifier<string>, new()
219	{
220	if (services is null)	×
221	throw new System.ArgumentNullException(nameof(services));	×
222
223	// standard crud commands
224	services.TryAddTransient<IRequestHandler<EntityDeleteCommand<string, TReadModel>, TReadModel>, EntityDeleteCommandHandler<TRepository, TEntity, TReadModel>>();	×
225
226	// pipeline registration, run in order registered
227	services.AddTransient<IPipelineBehavior<EntityDeleteCommand<string, TReadModel>, TReadModel>, EntityChangeNotificationBehavior<string, TEntity, TReadModel>>();	×
228
229	return services;	×
230	}
231	}

loresoft / MediatR.CommandQuery / 8664272182

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous