public void SaveProcessManagerAndPublishCommands_absorbs_command_publisher_exception_handler_exception()
{
// Arrange
var processManager = new FooProcessManager();
CancellationToken cancellationToken = CancellationToken.None;
ICommandPublisher commandPublisher = Mock.Of <ICommandPublisher>();
Mock.Get(commandPublisher)
.Setup(x => x.FlushCommands(processManager.Id, cancellationToken))
.ThrowsAsync(new InvalidOperationException());
var sut = new SqlProcessManagerDataContext <FooProcessManager>(
new FooProcessManagerDbContext(),
new JsonMessageSerializer(),
commandPublisher,
new DelegatingCommandPublisherExceptionHandler(
context =>
{
context.Handled = true;
throw new InvalidOperationException();
}));
// Act
Func <Task> action = () =>
sut.SaveProcessManagerAndPublishCommands(processManager, cancellationToken: cancellationToken);
// Assert
action.ShouldNotThrow();
}
public OefeningController(ILogger <OefeningController> logger, IOefeningRepository oefeningRepository, IPrestatieRepository prestatieRepository, ICommandPublisher commandPublisher)
{
_logger = logger;
_oefeningRepository = oefeningRepository;
_prestatieRepository = prestatieRepository;
_commandPublisher = commandPublisher;
}
public void given_command_publisher_fails_SaveProcessManagerAndPublishCommands_invokes_exception_handler()
{
// Arrange
var processManager = new FooProcessManager();
CancellationToken cancellationToken = CancellationToken.None;
Exception exception = new InvalidOperationException();
ICommandPublisher commandPublisher = Mock.Of <ICommandPublisher>();
Mock.Get(commandPublisher)
.Setup(x => x.FlushCommands(processManager.Id, cancellationToken))
.ThrowsAsync(exception);
ICommandPublisherExceptionHandler commandPublisherExceptionHandler = Mock.Of <ICommandPublisherExceptionHandler>();
var sut = new SqlProcessManagerDataContext <FooProcessManager>(
new FooProcessManagerDbContext(),
new JsonMessageSerializer(),
commandPublisher,
commandPublisherExceptionHandler);
// Act
Func <Task> action = () =>
sut.SaveProcessManagerAndPublishCommands(processManager, cancellationToken: cancellationToken);
// Assert
action.ShouldThrow <InvalidOperationException>().Which.Should().BeSameAs(exception);
Mock.Get(commandPublisherExceptionHandler).Verify(
x =>
x.Handle(It.Is <CommandPublisherExceptionContext>(
p =>
p.ProcessManagerType == typeof(FooProcessManager) &&
p.ProcessManagerId == processManager.Id &&
p.Exception == exception)),
Times.Once());
}
public void given_command_publisher_exception_handled_SaveProcessManagerAndPublishCommands_does_not_throw()
{
// Arrange
var processManager = new FooProcessManager();
CancellationToken cancellationToken = CancellationToken.None;
Exception exception = new InvalidOperationException();
ICommandPublisher commandPublisher = Mock.Of <ICommandPublisher>();
Mock.Get(commandPublisher)
.Setup(x => x.FlushCommands(processManager.Id, cancellationToken))
.ThrowsAsync(exception);
var sut = new SqlProcessManagerDataContext <FooProcessManager>(
new FooProcessManagerDbContext(),
new JsonMessageSerializer(),
commandPublisher,
new DelegatingCommandPublisherExceptionHandler(
context =>
context.Handled =
context.ProcessManagerType == typeof(FooProcessManager) &&
context.ProcessManagerId == processManager.Id &&
context.Exception == exception));
// Act
Func <Task> action = () =>
sut.SaveProcessManagerAndPublishCommands(processManager, cancellationToken: cancellationToken);
// Assert
action.ShouldNotThrow();
}
public GroupController(
IGroupService groupService,
IGroupMemberService groupMemberService,
IMediaHelper mediaHelper,
IGroupLinkProvider groupLinkProvider,
IUserService userService,
IGroupMediaService groupMediaService,
IIntranetUserService <IGroupMember> intranetUserService,
IProfileLinkProvider profileLinkProvider,
UmbracoHelper umbracoHelper,
IDocumentTypeAliasProvider documentTypeAliasProvider,
IImageHelper imageHelper,
IGroupPermissionsService groupPermissionsService,
ICommandPublisher commandPublisher)
: base(
groupService,
groupMemberService,
mediaHelper,
groupMediaService,
intranetUserService,
profileLinkProvider,
groupLinkProvider,
imageHelper,
commandPublisher)
{
_intranetUserService = intranetUserService;
_umbracoHelper = umbracoHelper;
_documentTypeAliasProvider = documentTypeAliasProvider;
_groupPermissionsService = groupPermissionsService;
}
private static ReactiveCommand FireCommands(
ICommandPublisher bus,
IEnumerable <Func <Command> > commands,
IObservable <bool> canExecute = null,
IScheduler scheduler = null,
string userErrorMsg = null,
TimeSpan?responseTimeout = null,
TimeSpan?ackTimeout = null)
{
if (scheduler == null)
{
scheduler = RxApp.MainThreadScheduler;
}
Func <object, Task> task = async _ => await Task.Run(() =>
{
foreach (var func in commands)
{
bus.Send(func(), userErrorMsg, responseTimeout, ackTimeout);
}
});
var cmd = ReactiveCommand.CreateFromTask(task, canExecute, scheduler);
cmd.ThrownExceptions
#pragma warning disable CS0618 // Type or member is obsolete
.SelectMany(ex => UserError.Throw(userErrorMsg, ex))
#pragma warning restore CS0618 // Type or member is obsolete
.ObserveOn(MainThreadScheduler).Subscribe(result =>
{
//This will return the recovery option returned from the registered user error handler
//right now this is a simple message box in the view code behind
/* n.b. this forces evaluation/execution of the select many */
});
return(cmd);
}
public VideoConverter(
ICommandPublisher commandPublisher,
IApplicationSettings applicationSettings)
{
_commandPublisher = commandPublisher;
_applicationSettings = applicationSettings;
}
public MentionService(
ICommandPublisher commandPublisher,
IIntranetUserContentProvider intranetUserContentProvider)
{
_commandPublisher = commandPublisher;
_intranetUserContentProvider = intranetUserContentProvider;
}
public AccountsController(
IUserRepository repo,
UserManager <SensateUser> userManager,
IEmailSender emailer,
IOptions <UserAccountSettings> options,
IPasswordResetTokenRepository tokens,
IChangeEmailTokenRepository emailTokens,
IChangePhoneNumberTokenRepository phoneTokens,
IUserTokenRepository tokenRepository,
ITextSendService text,
IUserService userService,
ICommandPublisher publisher,
IOptions <TextServiceSettings> text_opts,
IWebHostEnvironment env,
IHttpContextAccessor ctx,
ILogger <AccountsController> logger
) : base(repo, ctx)
{
this.m_userService = userService;
this._logger = logger;
this._manager = userManager;
this._mailer = emailer;
this._passwd_tokens = tokens;
this._email_tokens = emailTokens;
this._env = env;
this._tokens = tokenRepository;
this._phonetokens = phoneTokens;
this._settings = options.Value;
this._text = text;
this.m_publisher = publisher;
this._text_settings = text_opts.Value;
}
/// <summary>
/// Instantiate a new instance of the <see cref="AuthenticationService"/> class.
/// </summary>
public AuthenticationService(IEventStore <Guid> eventStore, ILogger logger, ICorrelationIdHelper correlationIdHelper, IAuthenticationTokenHelper <Guid> authenticationTokenHelper, IQueryFactory queryFactory, ICredentialRepository credentialRepository, IAuthenticationHashHelper authenticationHashHelper, ICommandPublisher <Guid> commandPublisher)
: base(eventStore, logger, correlationIdHelper, authenticationTokenHelper)
{
CredentialRepository = credentialRepository;
QueryFactory = queryFactory;
AuthenticationHashHelper = authenticationHashHelper;
CommandPublisher = commandPublisher;
}
//private readonly IDbContextOptions<PolisContext> _context;
public PolisEventListener(IDataMapper mapper, ICommandPublisher commandPublisher, IEventPublisher eventPublisher)
{
this.mapper = mapper;
_commandPublisher = commandPublisher;
_eventPublisher = eventPublisher;
mapper.Print();
//_context = context;
}
/// <summary>
/// Instantiate a replay command publisher used
/// </summary>
public ReplayCommandPublisher(IMicroserviceReplayHost host, ICommandPublisher commandPublisher, ILoggerFactory loggerFactory = null)
{
loggerFactory ??= new NullLoggerFactory();
Host = host;
CommandPublisher = commandPublisher;
Logger = loggerFactory.CreateLogger <ReplayCommandPublisher>();
}
/// <summary>
/// Instantiate a new instance of the <see cref="ConversationService"/> class.
/// </summary>
public ConversationService(IEventStore <Guid> eventStore, ILogger logger, ICorrelationIdHelper correlationIdHelper, IAuthenticationTokenHelper <Guid> authenticationTokenHelper, IConversationSummaryRepository conversationSummaryRepository, IQueryFactory queryFactory, IMessageRepository messageRepository, ICommandPublisher <Guid> commandPublisher)
: base(eventStore, logger, correlationIdHelper, authenticationTokenHelper)
{
ConversationSummaryRepository = conversationSummaryRepository;
QueryFactory = queryFactory;
MessageRepository = messageRepository;
CommandPublisher = commandPublisher;
}
public EventDispatcher(ReadOnlyDictionary <Type, IReadOnlyCollection <object> > domainEventHandlers,
ReadOnlyDictionary <Type, IReadOnlyCollection <object> > integrationEventHandlers,
ICommandPublisher commandPublisher)
{
_domainEventHandlers = domainEventHandlers;
_integrationEventHandlers = integrationEventHandlers;
_commandPublisher = commandPublisher;
}
/// <summary>
/// Instantiates a new instance of <see cref="SagaRepository{TAuthenticationToken}"/>
/// </summary>
public SagaRepository(IAggregateFactory sagaFactory, IEventStore <TAuthenticationToken> eventStore, IEventPublisher <TAuthenticationToken> publisher, ICommandPublisher <TAuthenticationToken> commandPublisher, ICorrelationIdHelper correlationIdHelper)
{
EventStore = eventStore;
Publisher = publisher;
CorrelationIdHelper = correlationIdHelper;
CommandPublisher = commandPublisher;
SagaFactory = sagaFactory;
}
static async Task ImportDataIntoSystemFromFile(ICommandPublisher commandPublisher, Guid klantId, string filePath)
{
var lines = File.ReadAllLines(filePath);
var exporter = new TextDataExporter();
var oefeningen = exporter.ReadAllOefeningenWithPrestatiesFromLines(lines);
var importer = new DataImporter(commandPublisher);
await importer.ImportOefeningenIntoSystem(oefeningen.ToList(), klantId);
}
public ConversationsController(ILogger logger, ICorrelationIdHelper correlationIdHelper, IConfigurationManager configurationManager, IAuthenticationTokenHelper <Guid> authenticationTokenHelper, IQueryFactory queryFactory, IConversationSummaryRepository conversationSummaryRepository, IMessageRepository messageRepository, IAuthenticationHelper authenticationHelper, ICommandPublisher <Guid> commandPublisher)
: base(logger, correlationIdHelper, configurationManager, authenticationTokenHelper)
{
QueryFactory = queryFactory;
ConversationSummaryRepository = conversationSummaryRepository;
MessageRepository = messageRepository;
AuthenticationHelper = authenticationHelper;
CommandPublisher = commandPublisher;
}
public LikesController(
IActivitiesServiceFactory activitiesServiceFactory,
IIntranetUserService <IIntranetUser> intranetUserService,
ILikesService likesService,
IContextTypeProvider contextTypeProvider,
ICommandPublisher commandPublisher)
: base(activitiesServiceFactory, intranetUserService, likesService, contextTypeProvider, commandPublisher)
{
}
public ApiKeysController(IUserRepository users, IApiKeyRepository keys,
ILogger <ApiKeysController> logger,
ICommandPublisher publisher,
IHttpContextAccessor ctx) : base(users, ctx)
{
this._keys = keys;
this.m_logger = logger;
this.m_publisher = publisher;
}
public AccountController(ICommandPublisher commandPublisher,
ILoggerFactory loggerFactory,
IJwtHelper jwtHelper,
IKlantDataMapper klantDataMapper)
{
_commandPublisher = commandPublisher;
_logger = loggerFactory.CreateLogger <AccountController>();
_jwtHelper = jwtHelper;
_klantDataMapper = klantDataMapper;
}
public CommentsController(
ICommentsService commentsService,
IIntranetUserService <IIntranetUser> intranetUserService,
IProfileLinkProvider profileLinkProvider,
IContextTypeProvider contextTypeProvider,
ICommandPublisher commandPublisher,
IActivitiesServiceFactory activitiesServiceFactory)
: base(commentsService, intranetUserService, profileLinkProvider, contextTypeProvider, commandPublisher, activitiesServiceFactory)
{
}
/// <summary>
/// Instantiates a new instance of <see cref="AkkaSaga{TAuthenticationToken}"/>
/// </summary>
protected AkkaSaga(ISagaUnitOfWork <TAuthenticationToken> unitOfWork, ILogger logger, IAkkaSagaRepository <TAuthenticationToken> repository, ICorrelationIdHelper correlationIdHelper, IAuthenticationTokenHelper <TAuthenticationToken> authenticationTokenHelper, ICommandPublisher <TAuthenticationToken> commandPublisher)
{
UnitOfWork = unitOfWork;
Logger = logger;
Repository = repository;
CorrelationIdHelper = correlationIdHelper;
AuthenticationTokenHelper = authenticationTokenHelper;
CommandPublisher = commandPublisher;
Changes = new ReadOnlyCollection <ISagaEvent <TAuthenticationToken> >(new List <ISagaEvent <TAuthenticationToken> >());
}
public static ReactiveCommand BuildFireCommand(
this ICommandPublisher bus,
Func <Command> commandFunc,
IScheduler scheduler = null,
string userErrorMsg = null,
TimeSpan?responseTimeout = null,
TimeSpan?ackTimeout = null)
{
return(FireCommands(bus, new[] { commandFunc }, null, scheduler, userErrorMsg, responseTimeout, ackTimeout));
}
/// <summary>
/// Creates a ReactiveCommand that will send the specified Command on the bus when executed. The ReactiveCommand's CanExecute will always be true.
/// </summary>
/// <param name="bus"></param>
/// <param name="commands"></param>
/// <param name="scheduler"></param>
/// <param name="userErrorMsg"></param>
/// <param name="responseTimeout"></param>
/// <param name="ackTimeout"></param>
/// <returns></returns>
public static ReactiveCommand <Unit, Unit> BuildSendCommands(
this ICommandPublisher bus,
IEnumerable <Func <Command> > commands,
IScheduler scheduler = null,
string userErrorMsg = null,
TimeSpan?responseTimeout = null,
TimeSpan?ackTimeout = null)
{
return(SendCommands(bus, commands, null, scheduler, userErrorMsg, responseTimeout, ackTimeout));
}
public TriggersController(IHttpContextAccessor ctx,
ISensorRepository sensors,
ISensorLinkRepository links,
ITriggerAdministrationRepository triggers,
ICommandPublisher publisher,
IApiKeyRepository keys) : base(ctx, sensors, links, keys)
{
this.m_triggers = triggers;
this.m_mqtt = publisher;
}
public PublishService(ICommandPublisher commandPublisher, IOptions <QueueNames> options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_commandPublisher = commandPublisher ?? throw new ArgumentNullException(nameof(commandPublisher));
_queueNames = options.Value;
}
public AkkaCommandBus(IBusHelper busHelper, IAuthenticationTokenHelper <TAuthenticationToken> authenticationTokenHelper, ICorrelationIdHelper correlationIdHelper, IDependencyResolver dependencyResolver, ILogger logger, ICommandPublisher <TAuthenticationToken> commandPublisher, ICommandReceiver <TAuthenticationToken> commandReceiver)
{
Logger = logger;
BusHelper = busHelper;
AuthenticationTokenHelper = authenticationTokenHelper;
CorrelationIdHelper = correlationIdHelper;
DependencyResolver = dependencyResolver;
EventWaits = new ConcurrentDictionary <Guid, IList <IEvent <TAuthenticationToken> > >();
CommandPublisher = commandPublisher;
CommandReceiver = commandReceiver;
}
public SqlProcessManagerDataContext(
ProcessManagerDbContext dbContext,
IMessageSerializer serializer,
ICommandPublisher commandPublisher)
: this(
dbContext,
serializer,
commandPublisher,
DefaultCommandPublisherExceptionHandler.Instance)
{
}
public SqlProcessManagerDataContext(
ProcessManagerDbContext dbContext,
IMessageSerializer serializer,
ICommandPublisher commandPublisher,
ICommandPublisherExceptionHandler commandPublisherExceptionHandler)
{
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
_commandPublisher = commandPublisher ?? throw new ArgumentNullException(nameof(commandPublisher));
_commandPublisherExceptionHandler = commandPublisherExceptionHandler ?? throw new ArgumentNullException(nameof(commandPublisherExceptionHandler));
}
public BestellingListener(IBestellingDatamapper datamapper, IKlantDatamapper klantDatamapper,
ICommandPublisher commandPublisher,
IEventPublisher eventPublisher)
{
_datamapper = datamapper;
_klantDatamapper = klantDatamapper;
_commandPublisher = commandPublisher;
_eventPublisher = eventPublisher;
_logger = NijnLogger.CreateLogger <BestellingListener>();
}
public DeviceController(NetworkDeviceViewBuilder deviceViews, NetworkDeviceService service, ICommandPublisher publisher)
{
_deviceViews = deviceViews;
_service = service;
_publisher = publisher;
}