public void Setup()
{
void Increment(string message)
{
}
_hubSinglePublisherSingleSubscriber.Subscribe <string>(Increment);
_hubSinglePublisherSingleSubscriberSimple.Subscribe <string>(Increment);
void IncrementMultiple(int msg)
{
}
_hubSinglePublisherMultipleSubscriber.Subscribe <int>(IncrementMultiple);
_hubSinglePublisherMultipleSubscriber.Subscribe <int>(IncrementMultiple);
_hubSinglePublisherMultipleSubscriber.Subscribe <int>(IncrementMultiple);
_hubSinglePublisherMultipleSubscriberSimple.Subscribe <int>(IncrementMultiple);
_hubSinglePublisherMultipleSubscriberSimple.Subscribe <int>(IncrementMultiple);
_hubSinglePublisherMultipleSubscriberSimple.Subscribe <int>(IncrementMultiple);
_hubMultiplePublisherSingleSubscriber.Subscribe <string>(Increment);
_hubMultiplePublisherSingleSubscriberSimple.Subscribe <string>(Increment);
_hubMultiplePublisherSingleSubscriberAndGlobalAuditHandler.RegisterGlobalHandler((type, msg) => { });
_hubMultiplePublisherSingleSubscriberAndGlobalAuditHandlerSimple.RegisterGlobalHandler((type, msg) => { });
_hubMultiplePublisherSingleSubscriberAndGlobalAuditHandler.Subscribe <string>(x => { });
_hubMultiplePublisherSingleSubscriberAndGlobalAuditHandlerSimple.Subscribe <string>(x => { });
}
/// <inheritdoc />
public Task StartAsync(CancellationToken cancellationToken)
{
// Subscribe to event aggregator
_messageHubSubscriptions.Add(_messageHub.Subscribe <RequestSyncEvent>((e) => HandleGoogleRequestSync(e)));
_messageHubSubscriptions.Add(_messageHub.Subscribe <ReportStateEvent>((e) => HandleGoogleReportState(e)));
return(Task.CompletedTask);
}
/// <inheritdoc />
protected override Task StartServiceAsync(CancellationToken cancellationToken)
{
// Subscribe to event aggregator
_messageHubSubscriptions.Add(_messageHub.Subscribe <Command>((e) => HandleGoogleHomeCommand(e)));
_messageHubSubscriptions.Add(_messageHub.Subscribe <ConfigSubscriptionChangeEvent>((e) => HandleConfigSubscriptionChange(e)));
return(Task.CompletedTask);
}
public IndexViewModel(IMessageHub eventAggregator, ITicketRepository ticketRepository)
{
_eventAggregator = eventAggregator;
_ticketRepository = ticketRepository;
_ticketScanAddedSubscription = _eventAggregator.Subscribe <TicketScanAdded>(
message => OnPropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(TicketScans))));
_ticketScanUpdatedSubscription = _eventAggregator.Subscribe <TicketScanUpdated>(
message => OnPropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(TicketScans))));
}
public StatePresenter(IStateView stateView, IMessageHub aggregator, IGame game)
{
_stateView = stateView;
_stateView.SunClicked += OnSunClicked;
_game = game;
_aggregator = aggregator;
_aggregator.Subscribe <GameFinishedMessage>(m => OnGameFinished(m.Game));
_aggregator.Subscribe <FlaggedCountChangedMessage>(m => OnFlaggedCountChanged(m.Game));
}
public UserSynchronizationServiceLogger(
ILoggerFactory loggerFactory,
IMessageHub messageHub)
{
var logger = loggerFactory.CreateLogger <UserSynchronizationService>();
messageHub.Subscribe <UserSynchronizationServiceStart>(message => logger.LogInformation($"Started {message.UserType} user synchronization{(Logging.LogDestination == LogDestinations.Console ? $" {DateTimeOffset.Now:yyyy-MM-dd hh:mm:ss}" : string.Empty)}"));
messageHub.Subscribe <UsersAcquired>(message => logger.LogInformation($"Synchronizing {message.Count} {message.UserType} Users"));
messageHub.Subscribe <UserSynchronizationServiceException>(message => message.Exceptions.ToList().ForEach(exception => logger.LogError(exception, $"{message.UserType} User Synchronization Exception")));
messageHub.Subscribe <UserSynchronizationServiceEnd>(message => logger.LogInformation($"Finished {message.UserType} user synchronization{(Logging.LogDestination == LogDestinations.Console ? $" {DateTimeOffset.Now:yyyy-MM-dd HH:mm:ss}" : string.Empty)}"));
}
/// <summary>
/// Uses the creator to create a component, and then add that component to the list.
/// </summary>
/// <param name="creator"> The specific component creator. </param>
/// <param name="fileName"> The filename (location) that the component uses to read from. </param>
/// <returns></returns>
public bool RegisterComponent(IComponentCreator creator, string fileName)
{
var response = false;
// Contract requirements.
if (creator != null && !string.IsNullOrWhiteSpace(fileName))
{
var component = creator.CreateComponent(Hub, fileName);
Hub.Subscribe <string>(async(s) => await component.Processor.ProcessAsync(fileName).ConfigureAwait(false));
Components.Add(component);
response = true;
}
return(response);
}
public MessageTypeSwitchService(ILogger log, IMessageHub hub)
{
_logger = log;
_messageHub = hub;
_token = _messageHub.Subscribe <Message>(OnMessageReceivedEvent);
}
public override void EndInit()
{
base.EndInit();
if (Inventory.ColumnDefinitions.Count > 0 && Inventory.RowDefinitions.Count > 0)
{
for (int y = 0; y < Inventory.ColumnDefinitions.Count; y++)
{
for (int x = 0; x < Inventory.RowDefinitions.Count; x++)
{
Border border = new Border
{
Background = Brushes.LightGray,
BorderBrush = Brushes.Black,
BorderThickness = new Thickness(0.75),
Width = CellWidth,
Height = CellHeight,
};
Grid.SetColumn(border, y);
Grid.SetRow(border, x);
Inventory.Children.Add(border);
}
}
hub = MessageHub;
subscriptionToken = hub.Subscribe <ItemPositionUpdate>(ItemPositionUpdate);
AddItem(0, 0, 0, "https://www.clipartmax.com/png/full/414-4147920_bow-arrow-symbol-vector-icon-illustration-triangle.png", isStackable: true, quantity: 5);
AddItem(1, 1, 0, "https://icons.iconarchive.com/icons/chanut/role-playing/256/Sword-icon.png", spanY: 2);
AddItem(2, 0, 2, "https://icons.iconarchive.com/icons/google/noto-emoji-objects/128/62967-shield-icon.png", spanY: 3, spanX: 3);
}
}
public MovementService(ILogger log, IMessageHub hub)
{
_logger = log;
_messageHub = hub;
_token = _messageHub.Subscribe <MovementMessage>(OnMovementReceivedEvent);
}
public TimingSession(Id <TimingSessionDto> id,
IEventRepository eventRepository,
IRecordingService recordingService, IRecordingServiceRepository recordingServiceRepository,
IAutoMapperProvider autoMapper,
IMessageHub messageHub, ISystemClock clock)
{
this.Id = id;
this.eventRepository = eventRepository;
this.recordingService = recordingService;
this.recordingServiceRepository = recordingServiceRepository;
this.autoMapper = autoMapper;
this.messageHub = messageHub;
this.clock = clock;
messageHub.Subscribe <UpstreamDataSyncComplete>(_ => Reload());
messageHub.Subscribe <StorageUpdated>(x => Reload(false, x));
}
public ActionService(ILogger log, IMessageHub hub)
{
_logger = log;
_messageHub = hub;
_token = _messageHub.Subscribe <ActionMessage>(OnActionReceivedEvent);
}
public ReaderWriter(INode creator,
IMessageHub messageHub,
IEnumerable <IConfiguration> configMap,
IMessageSerializer serializer)
{
var configurations = configMap.ToDictionary(c => c.Key, c => c);
this.serializer = serializer;
op = new CurrentOperation
{
Phase = new ObservableAtomicValue <OperationPhase>(OperationPhase.Idle),
Type = new ObservableAtomicValue <OperationType>(OperationType.Idle),
Accepted = new ObservableConcurrentDictionary <int, INode>(Enumerable.Empty <KeyValuePair <int, INode> >()),
ConfigurationMap = new ObservableConcurrentDictionary <IConfigurationIndex, IConfiguration>(configurations)
};
gc = new GarbageCollectionOperation {
Phase = new ObservableAtomicValue <OperationPhase>(OperationPhase.Idle)
};
this.creator = creator;
this.configMap = new ObservableConcurrentDictionary <IConfigurationIndex, IConfiguration>(configurations);
this.messageHub = messageHub;
value = new ObjectValue {
Value = 0
};
tag = new Tag(creator);
localPhase = new PhaseNumber();
operationQueue = new BlockingCollection <OperationRequest>(new ConcurrentQueue <OperationRequest>());
eventHandlers = new EventHandlerList();
status = new ObservableAtomicValue <NodeStatus>(NodeStatus.Idle);
world = new ObservableConcurrentDictionary <int, INode>();
phaseVector = new ObservableConcurrentDictionary <INode, IPhaseNumber>();
preJoinAck = new ObservableCondition(() => status.Get() == NodeStatus.Active, new[] { status });
preOutSend = new ObservableCondition(() => status.Get() == NodeStatus.Active, new[] { status });
preQueryFix = new ObservableCondition(QueryFixCondition,
new IChangeNotifiable[] { status, op.Type, op.Phase, op.Accepted, op.ConfigurationMap });
prePropagationFix = new ObservableCondition(PropagationFixCondition,
new IChangeNotifiable[] { status, op.Type, op.Phase, op.Accepted, op.ConfigurationMap });
preReadAck = new ObservableCondition(() => status.Get() == NodeStatus.Active &&
op.Type.Get() == OperationType.Read &&
op.Phase.Get() == OperationPhase.Done,
new IChangeNotifiable[] { status, op.Type, op.Phase });
preWriteAck = new ObservableCondition(() => status.Get() == NodeStatus.Active &&
op.Type.Get() == OperationType.Write &&
op.Phase.Get() == OperationPhase.Done,
new IChangeNotifiable[] { status, op.Type, op.Phase });
new Thread(ProcessReadWriteRequests).Start();
new Thread(OutJoinAck).Start();
new Thread(OutSend).Start();
new Thread(IntQueryFix).Start();
new Thread(IntPropagationFix).Start();
new Thread(OutReadAck).Start();
new Thread(OutWriteAck).Start();
var listener = messageHub.Subscribe(creator);
listener.Where(m => m.Body.MessageType.ToMessageType() == MessageTypes.JoinRw)
.Subscribe(new MessageStreamListener(OnJoinReceived));
listener.Where(m => m.Body.MessageType.ToMessageType() == MessageTypes.Gossip)
.Subscribe(new MessageStreamListener(OnGossipReceived));
}
public SubthemeSynchronizerLogger(
ILoggerFactory loggerFactory,
IMessageHub messageHub)
{
var logger = loggerFactory.CreateLogger <SubthemeSynchronizer>();
messageHub.Subscribe <SubthemeSynchronizerStart>(_ =>
{
_subthemeIndex = 0;
_subthemeProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Started subtheme synchronizer");
}
});
messageHub.Subscribe <SubthemesAcquired>(message =>
{
_subthemeIndex = 0;
_subthemeCount = message.Count;
logger.LogInformation($"Acquired {message.Count} subthemes to process for theme '{message.Theme}'");
});
messageHub.Subscribe <SynchronizingSubthemeStart>(message =>
{
_subthemeIndex++;
_subthemeProgressFraction = _subthemeIndex / _subthemeCount;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation(Invariant($"Started synchronizing subtheme '{message.Theme}-{message.Subtheme}': index {_subthemeIndex}, progress {_subthemeProgressFraction:##0.00%}"));
}
});
messageHub.Subscribe <SynchronizingSubthemeException>(message => logger.LogError(message.Exception, $"Synchronizing Subtheme '{message.Theme}-{message.Subtheme}' Exception"));
messageHub.Subscribe <SynchronizingSubthemeEnd>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Finished synchronizing subtheme '{message.Theme}-{message.Subtheme}'");
}
});
messageHub.Subscribe <SubthemeSynchronizerException>(message => logger.LogError(message.Exception, $"Subtheme Synchronizer Exception for theme '{message.Theme}'"));
messageHub.Subscribe <SubthemeSynchronizerEnd>(_ =>
{
_subthemeIndex = 0;
_subthemeProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Finished subtheme synchronizer");
}
});
}
public FieldPresenter(IFieldView fieldView, IGame game, IMessageHub aggregator)
{
_game = game;
_fieldView = fieldView;
_fieldView.CellClick += OnCellClick;
_fieldView.FieldMouseDown += OnFieldMouseDown;
_fieldView.RenderField(_game.Minefield);
_aggregator = aggregator;
_aggregator.Subscribe <GameStartedMessage>(m => OnGameStarted(m.Game));
}
public RfidService(StorageService storageService, IMessageHub messageHub,
ISystemClock systemClock, IMapper mapper)
{
this.storageService = storageService;
this.messageHub = messageHub;
this.systemClock = systemClock;
this.mapper = mapper;
messageHub.Subscribe <RfidOptions>(RfidOptionsChanged);
factory = new UniversalTagStreamFactory();
factory.UseAlienProtocol();
factory.UseSerialProtocol();
RfidOptionsChanged(storageService.GetRfidOptions());
}
public AssetUncompressionLogger(
ILoggerFactory loggerFactory,
IMessageHub messageHub)
{
var logger = loggerFactory.CreateLogger <AssetUncompression>();
messageHub.Subscribe <ReaderExtractionEventArgs <IEntry> >(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Uncompressing {message.Item.Key}: {message.ReaderProgress.PercentageRead}%");
}
});
}
private static void Bootstrap()
{
IKernel kernel = new StandardKernel();
//Perform binding here
//See https://github.com/ninject/Ninject/wiki/Dependency-Injection-With-Ninject for help
//Hint: You may need to use Bind<A, B>() depending on your implementation
//Hint: You may need .InSingletonScope()
kernel.Bind <IMessageHub>().To <MessageHub>().InSingletonScope();
kernel.Bind <IElevatorStatus>().To <ElevatorStatus>().InSingletonScope();
kernel.Bind <IElevatorControls>().To <ElevatorControls>().InSingletonScope();
messageHub = kernel.Get <IMessageHub>();
elevatorControls = kernel.Get <IElevatorControls>();
messageHub.Subscribe <FloorChangedMessage>(ElevatorStatusOnFloorChanged);
}
public VolumeSpikesDetector(IMessageHub messageHub,
IOptions <AppSettings> appSettings,
ISymbolService symbolService,
ILastTradesService lastTradesService,
IVolumeRecordService volumeRecordService,
ILogger <VolumeSpikesDetector> logger)
{
_logger = logger;
_appSettings = appSettings;
_symbolService = symbolService;
_lastTradesService = lastTradesService;
_volumeRecordService = volumeRecordService;
LoadSymbols();
messageHub.Subscribe <IList <StreamingMessage> >(HandleMessages);
}
public SetSynchronizationServiceLogger(
ILoggerFactory loggerFactory,
IMessageHub messageHub)
{
var logger = loggerFactory.CreateLogger <SetSynchronizationService>();
messageHub.Subscribe <SetSynchronizationServiceStart>(_ => logger.LogInformation($"Started set synchronization{(Logging.LogDestination == LogDestinations.Console ? $" {DateTimeOffset.Now:yyyy-MM-dd HH:mm:ss}" : string.Empty)}"));
messageHub.Subscribe <InsightsAcquired>(message => logger.LogInformation($"Last Updated: {(message.SynchronizationTimestamp.HasValue ? message.SynchronizationTimestamp.Value.ToString("yyyy-MM-dd HH:mm:ss") : "Never")}"));
messageHub.Subscribe <ProcessingThemeStart>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Started processing theme: {message.Name}");
}
});
messageHub.Subscribe <ProcessingSubthemeStart>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Started processing subtheme: {message.Name}");
}
});
messageHub.Subscribe <ProcessingSubthemeEnd>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Finished processing subtheme: {message.Name}");
}
});
messageHub.Subscribe <ProcessingThemeException>(message => logger.LogError(message.Exception, $"Processing Theme '{message.Name}' Exception"));
messageHub.Subscribe <ProcessingThemeEnd>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Finished processing theme: {message.Name}");
}
});
messageHub.Subscribe <SetSynchronizationServiceException>(message => logger.LogError(message.Exception, "Set Synchronization Exception"));
messageHub.Subscribe <SetSynchronizationServiceEnd>(_ => logger.LogInformation($"Finished set synchronization{(Logging.LogDestination == LogDestinations.Console ? $" {DateTimeOffset.Now:yyyy-MM-dd HH:mm:ss}" : string.Empty)}"));
}
public UnshelveViewModel(
[NotNull] string directoryPath,
[NotNull] GitInfo gitInfo,
[NotNull] TfsInfo tfsInfo,
[NotNull] IMessageHub messageHub,
[NotNull] IGitUtility gitUtility,
[NotNull] ICmdUtility cmdUtility,
[NotNull] IGitTfsUtility gitTfsUtility,
[NotNull] ITfsUtility tfsUtility,
[NotNull] SynchronizationContext synchronizationContext,
[NotNull] Func <string, bool, ConfirmationViewModel> confirmationViewModelFactory,
[NotNull] Func <ConfirmationViewModel, IConfirmationWindow> confirmationWindowFactory,
[NotNull] ICommandManager commandManager,
[NotNull] IRateLimiter rateLimiter)
: base(commandManager)
{
_messageHub = messageHub ?? throw new ArgumentNullException(nameof(messageHub));
_gitUtility = gitUtility ?? throw new ArgumentNullException(nameof(gitUtility));
_cmdUtility = cmdUtility ?? throw new ArgumentNullException(nameof(cmdUtility));
_gitTfsUtility = gitTfsUtility ?? throw new ArgumentNullException(nameof(gitTfsUtility));
_tfsUtility = tfsUtility ?? throw new ArgumentNullException(nameof(tfsUtility));
_synchronizationContext = synchronizationContext ?? throw new ArgumentNullException(nameof(synchronizationContext));
_confirmationViewModelFactory = confirmationViewModelFactory ?? throw new ArgumentNullException(nameof(confirmationViewModelFactory));
_confirmationWindowFactory = confirmationWindowFactory ?? throw new ArgumentNullException(nameof(confirmationWindowFactory));
_rateLimiter = rateLimiter ?? throw new ArgumentNullException(nameof(rateLimiter));
_gitInfo = gitInfo ?? throw new ArgumentNullException(nameof(gitInfo));
_tfsInfo = tfsInfo ?? throw new ArgumentNullException(nameof(tfsInfo));
_directoryPath = directoryPath ?? throw new ArgumentNullException(nameof(directoryPath));
UnshelveCommand = AddCommand(Unshelve, () => CanExecute);
CancelCommand = AddCommand(Cancel, () => !IsLoading);
OpenShelvesetInBrowserCommand = AddCommand(OpenShelvesetInBrowser, () => ShelvesetName != null);
CopyShelvesetToClipboardCommand = AddCommand(CopyShelvesetToClipboard, () => ShelvesetName != null);
if (User == null)
{
UsersSearchPattern = string.Empty; // sets current user
}
_messageHub.Publish(DialogType.Unshelve);
_subscriptionTokens.Add(messageHub.Subscribe <TaskState>(OnTaskAction));
}
public void RetrieveTicketScan(string identifier)
{
if (!(_identifier is null))
{
throw new InvalidOperationException("Already retrieved ticket scan");
}
if (identifier is null)
{
throw new ArgumentNullException(nameof(identifier), "Identifier cannot be null");
}
_identifier = identifier;
if (Result?.Status == TicketScanStatus.Started)
{
_ticketScanUpdatedSubscription = _eventAggregator.Subscribe <TicketScanUpdated>(
message => OnPropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Message))));
}
}
public ThumbnailSynchronizerLogger(
ILoggerFactory loggerFactory,
IMessageHub messageHub)
{
var logger = loggerFactory.CreateLogger <ThumbnailSynchronizer>();
messageHub.Subscribe <ThumbnailSynchronizerStart>(_ =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Started thumbnail synchronizer");
}
});
messageHub.Subscribe <ThumbnailAcquired>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Acquired thumbnail '{message.Thumbnail}' to process");
}
});
messageHub.Subscribe <SynchronizingThumbnailStart>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Started synchronizing thumbnail '{message.Thumbnail}'");
}
});
messageHub.Subscribe <SynchronizingThumbnailEnd>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Finished synchronizing thumbnail '{message.Thumbnail}'");
}
});
messageHub.Subscribe <ThumbnailSynchronizerException>(message => logger.LogError(message.Exception, "Thumbnail Synchronizer Exception"));
messageHub.Subscribe <ThumbnailSynchronizerEnd>(_ =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Finished thumbnail synchronizer");
}
});
}
public ShelveViewModel(
[NotNull] string directoryPath,
[NotNull] GitInfo gitInfo,
[NotNull] TfsInfo tfsInfo,
[NotNull] IMessageHub messageHub,
[NotNull] IGitUtility gitUtility,
[NotNull] ICmdUtility cmdUtility,
[NotNull] IGitTfsUtility gitTfsUtility,
[NotNull] ITfsUtility tfsUtility,
[NotNull] SynchronizationContext synchronizationContext,
[NotNull] Func <string, bool, ConfirmationViewModel> confirmationViewModelFactory,
[NotNull] Func <ConfirmationViewModel, IConfirmationWindow> confirmationWindowFactory,
[NotNull] ICommandManager commandManager)
: base(commandManager)
{
_messageHub = messageHub ?? throw new ArgumentNullException(nameof(messageHub));
_gitUtility = gitUtility ?? throw new ArgumentNullException(nameof(gitUtility));
_cmdUtility = cmdUtility ?? throw new ArgumentNullException(nameof(cmdUtility));
_gitTfsUtility = gitTfsUtility ?? throw new ArgumentNullException(nameof(gitTfsUtility));
_tfsUtility = tfsUtility ?? throw new ArgumentNullException(nameof(tfsUtility));
_synchronizationContext = synchronizationContext ?? throw new ArgumentNullException(nameof(synchronizationContext));
_confirmationViewModelFactory = confirmationViewModelFactory ?? throw new ArgumentNullException(nameof(confirmationViewModelFactory));
_confirmationWindowFactory = confirmationWindowFactory ?? throw new ArgumentNullException(nameof(confirmationWindowFactory));
_gitInfo = gitInfo ?? throw new ArgumentNullException(nameof(gitInfo));
_tfsInfo = tfsInfo ?? throw new ArgumentNullException(nameof(tfsInfo));
_directoryPath = directoryPath ?? throw new ArgumentNullException(nameof(directoryPath));
ShelveOrCheckinCommand = AddCommand(ShelveOrCheckin, () => CanExecute);
CancelCommand = AddCommand(Cancel, () => !IsLoading);
IsDirty = CommitDirty = _gitInfo.IsDirty;
ShelvesetName = GetShelvesetName();
CommitMessage = _gitInfo.CommitMessage ?? string.Empty;
CommitMessages = _gitInfo.CommitMessages;
_messageHub.Publish(DialogType.Shelve);
_subscriptionTokens.Add(messageHub.Subscribe <TaskState>(OnTaskAction));
}
public UserSynchronizerLogger(
ILoggerFactory loggerFactory,
IMessageHub messageHub)
{
var logger = loggerFactory.CreateLogger <UserSynchronizer>();
messageHub.Subscribe <UserSynchronizerStart>(message =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Started user synchronizer for {message.UserType} user '{message.Username}'");
}
});
messageHub.Subscribe <AllMyBricksToBricksetStart>(_ =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Started update of Brickset.com with changes made in All My Bricks");
}
});
messageHub.Subscribe <AllMyBricksToBricksetAcquiringSetsStart>(_ =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Acquiring All My Bricks user sets to update in Brickset.com");
}
});
messageHub.Subscribe <AllMyBricksToBricksetAcquiringSetsEnd>(message =>
{
_setCount = message.Count;
_setIndex = 0;
logger.LogInformation($"Acquired {message.Count} All My Bricks user sets to update in Brickset.com");
});
messageHub.Subscribe <UserSynchronizerSynchronizingSetStart>(message =>
{
_setIndex++;
_setProgressFraction = _setIndex / _setCount;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Started synchronizing set {message.SetId}: index {_setIndex}, progress {_setProgressFraction:##0.00%}");
}
});
messageHub.Subscribe <UserSynchronizerSynchronizingSetEnd>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Finished synchronizing set {message.SetId}");
}
});
messageHub.Subscribe <AllMyBricksToBricksetEnd>(_ =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Finished update of Brickset.com with changes made in All My Bricks");
}
});
messageHub.Subscribe <BricksetToAllMyBricksStart>(_ =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Started adding Brickset.com user sets missing in All My Bricks");
}
});
messageHub.Subscribe <BricksetToAllMyBricksAcquiringSetsStart>(_ =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Acquiring Brickset.com user sets missing in All My Bricks");
}
});
messageHub.Subscribe <BricksetToAllMyBricksAcquiringSetsEnd>(message =>
{
_setCount = message.Count;
_setIndex = 0;
logger.LogInformation($"Acquired {message.Count} user sets from Brickset.com missing in All My Bricks");
});
messageHub.Subscribe <BricksetToAllMyBricksEnd>(_ =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation("Finished adding Brickset.com user sets missing in All My Bricks");
}
});
messageHub.Subscribe <UserSynchronizerException>(message => logger.LogError(message.Exception, $"Synchronizing {message.UserType} User '{message.Username}' Exception"));
messageHub.Subscribe <UserSynchronizerEnd>(message =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Finished user synchronizer for {message.UserType} user '{message.Username}'");
}
});
}
public Sut(IMessageHub MessageHub)
{
MessageHub.Subscribe <RefreshMessage>("Refresh", RefreshMethod);
MessageHub.Subscribe <CancelMessage>("Cancel", CancelMethod);
}
public SetSynchronizerLogger(
ILoggerFactory loggerFactory,
IMessageHub messageHub)
{
var logger = loggerFactory.CreateLogger <SetSynchronizer>();
messageHub.Subscribe <SetSynchronizerStart>(message =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Started set synchronizer{(message.ForSubtheme ? " for subtheme" : string.Empty)}");
}
});
messageHub.Subscribe <AcquiringSetsStart>(message =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Acquiring sets from '{message.Theme}-{message.Subtheme}' to process for year {message.Year}");
}
});
messageHub.Subscribe <AcquiringSetsEnd>(message =>
{
_setCount = message.Count;
_setIndex = 0;
logger.LogInformation($"Acquired {message.Count} sets {(message.Year.HasValue ? $"from '{message.Theme}-{message.Subtheme}' " : string.Empty)}to process{(message.Year.HasValue ? $" for year {message.Year}" : string.Empty)}");
});
messageHub.Subscribe <SynchronizingSetStart>(message =>
{
_setIndex++;
_setProgressFraction = _setIndex / _setCount;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation(Invariant($"Started synchronizing set '{message.IdentifierLong}': index {_setIndex}, progress {_setProgressFraction:##0.00%}"));
}
});
messageHub.Subscribe <SynchronizingSetException>(message => logger.LogError(message.Exception, $"Synchronizing Set '{message.IdentifierLong}' Exception"));
messageHub.Subscribe <SynchronizingSetEnd>(message =>
{
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Finished synchronizing set '{message.IdentifierLong}'");
}
});
messageHub.Subscribe <SetSynchronizerException>(message => logger.LogError(message.Exception, "Set Synchronizer Exception"));
messageHub.Subscribe <SetSynchronizerEnd>(message =>
{
_setIndex = 0;
_setProgressFraction = 0;
if (Logging.LogVerbosity == LogVerbosity.FullLogging)
{
logger.LogInformation($"Finished set synchronizer{(message.ForSubtheme ? " for subtheme" : string.Empty)}");
}
});
}
private void SubscribeToEvents()
{
_eventAggregator.Subscribe <ViewClosedEvent>(ViewClosed);
}
public static IDisposable SubscribeDisposable <T>(this IMessageHub messageHub, Action <T> action)
{
var subId = messageHub.Subscribe(action);
return(Disposable.Create(() => messageHub.Unsubscribe(subId)));
}
public Guid AddListener <T>(Action <T> listener)
{
return(_hub.Subscribe <T>(listener));
}