public void ObserverShouldOnlyReceiveSubscribedNotifications()
{
// Arrange
var eventAggregator = new EventAggregator();
var observer1 = new Mock<IObserve<TestEvent>>();
var observer2 = new Mock<IObserve<OtherEvent>>();
eventAggregator.Subscribe(observer1.Object);
eventAggregator.Subscribe(observer2.Object);
var testEvent = new TestEvent();
var otherEvent = new OtherEvent();
// Act
eventAggregator.Publish(testEvent);
eventAggregator.Publish(otherEvent);
// Assert
observer1.Verify(x => x.OnNext(It.IsAny<IEvent>()), Times.Once);
observer1.Verify(x => x.OnNext(testEvent), Times.Once);
observer2.Verify(x => x.OnNext(otherEvent), Times.Once);
}
public App()
{
try
{
IUnityContainer unityContainer = new UnityContainer();
var connectionString = System.Configuration.ConfigurationSettings.AppSettings.Get("webService");
IWebservice webService = new Webservice(connectionString);
EventAggregator eventAggregator = new EventAggregator();
unityContainer.RegisterInstance<IEventAggregator>(eventAggregator);
unityContainer.RegisterInstance<IWebservice>(webService);
IMessaging emailMessenger = new EmailMessaging();
unityContainer.RegisterInstance<IMessaging>(emailMessenger);
var regionManager = new RegionManager();
regionManager.Regions.Add(new Region() { Name = "MainContentRegion" });
unityContainer.RegisterInstance<IRegionManager>(regionManager);
ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(unityContainer));
}
catch (Exception ex)
{
logger.Error("Error in app constructor", ex);
}
}
public void a_published_message_is_received_by_multiple_subscribers()
{
// When the bus publishes a message, it is sent through the socket
var consumer = new ZeroConsumer<Message>("tcp://localhost:5562");
var bus = new BusAdapter();
bus.AttachConsumer(consumer);
// Meanwhile, the aggregator waits for messages from the same socket
var producer = new ZeroProducer<Message>("tcp://*:5562");
var aggregator = new EventAggregator<Message>();
aggregator.AttachTo(producer);
// While two test consumers are subscribed to the aggregator
// (the syntax looks like it's the other way around)
var confirmById = new FakeEventConsumer();
var confirmAsReceived = new TestConsumer();
aggregator.SubscribeTo(confirmById);
aggregator.SubscribeTo(confirmAsReceived);
// When we drop a message on the bus, the test consumer should get it
var @event = new FakeEvent();
bus.Publish(@event);
// Pause the thread so the producer (via aggregator) can send to the test consumer
var timeout = TimeSpan.FromSeconds(1).TotalMilliseconds;
Thread.Sleep((int)timeout);
Assert.IsTrue(confirmAsReceived.Received);
Assert.AreEqual(@event.Id, confirmById.Id);
producer.Dispose();
consumer.Dispose();
}
protected override void Given()
{
eventAggregator = new EventAggregator();
view = new Mock<ITerritoryStatsView>();
territoryStats = new TerritoryStatsPresentationModel(
view.Object, eventAggregator);
}
public ActivityFinderPopupViewModel(BcontrolDataHandler datahandler,C1DataGrid searchGrid)
{
eventaggregator = EventAggregator.Instance;
IsVisible = false;
_datahandler = datahandler;
_datahandler.SearchInitialDataRetrieved += new EventHandler<GetSearchInitialDataCompletedEventArgs>(bcontrolDataHandler_SearchInitialDataRetrieved);
_datahandler.SearchByMapListRetrieved +=new EventHandler<GetSearchMapListCompletedEventArgs>(bcontrolDatahandler_SearchByMapListRetrieved);
_datahandler.SearchByGlobalHeadListRetrieved += new EventHandler<GetSearchGlobalHeadListCompletedEventArgs>(bcontrolDatahandler_SearchByGlobalHeadListRetrieved);
_datahandler.SearchByGlobalFunctionListRetrieved += new EventHandler<GetSearchGlobalFunctionListCompletedEventArgs>(bcontrolDatahandler_SearchByGlobalFunctionListRetrieved);
_datahandler.SearchByBusinessAreaListRetrieved += new EventHandler<GetSearchBusinessAreaListCompletedEventArgs>(bcontrolDatahandler_SearchByBusinessAreaListRetrieved);
_datahandler.SearchByBusinessFunctionListRetrieved += new EventHandler<GetSearchBusinessFunctionListCompletedEventArgs>(bcontrolDatahandler_SearchByBusinessFunctionListRetrieved);
_datahandler.SearchBySubFunctionListRetrieved += new EventHandler<GetSearchSubFunctionListCompletedEventArgs>(bcontrolDatahandler_SearchByBusinessSubFunctionListRetrieved);
_datahandler.SearchByLevelDataRetrieved += new EventHandler<GetSearchResultsBylevelCompletedEventArgs>(bcontrolDataHandler_SearchByLevelDataRetrieved);
_datahandler.SearchByHierarchyDataRetrieved += new EventHandler<GetSearchResultsByHierarchyCompletedEventArgs>(bcontrolDataHandler_SearchByHierarchyDataRetrieved);
_datahandler.DiagramTemplateLinkRetrieved += new EventHandler<GetDiagramTemplateLinkCompletedEventArgs>(bcontrolDataHandler_DiagramTemplateLinkRetrieved);
_datahandler.ExisitingActivitiesRetrieved +=new EventHandler<GetExisitingActivitiesCompletedEventArgs>(bcontrolDatahandler_ExisitingActivitiesRetrieved);
_isModifiedLinks = false;
_searchResultsList = new ObservableCollection<ActivitySet>();
_datahandler.GetDiagramTemplateLink();
ErrorMessage = "";
_searchGrid = searchGrid;
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
RegisterServices();
EventAggregator = new EventAggregator();
}
public UploadReportHierarchyViewModel(StringBuilder log, C1DataGrid grid, BcontrolDataHandler bcontrolDataHandler)
{
eventaggregator = EventAggregator.Instance;
_log = log;
_grid = grid;
PreviewCommand = new RelayCommand(PreviewAction);
PreviewCommand.IsEnabled = false;
UploadCommand = new RelayCommand(UploadAction);
UploadCommand.IsEnabled = false;
CloseCommand = new RelayCommand(CloseAction);
CloseCommand.IsEnabled = true;
_datahandler = bcontrolDataHandler;
_datahandler.ClearBcontrolHierarchyDataRetrieved += new EventHandler<ClearBcontrolHierarchyDataCompletedEventArgs>(_datahandler_ClearBcontrolHierarchyDataRetrieved);
_datahandler.AddBcontrolHierarchyDataRetrieved += new EventHandler<AddBcontrolHierarchyDataCompletedEventArgs>(_datahandler_AddBcontrolHierarchyDataRetrieved);
_datahandler.CompleteAddBcontrolHierarchyDataRetrieved += new EventHandler<CompleteAddBcontrolHierarchyDataCompletedEventArgs>(_datahandler_CompleteAddBcontrolHierarchyDataRetrieved);
_columns = new Dictionary<string, ReportField>();
_columns.Add("Map Name", new ReportField(100, true));
_columns.Add("Level", new ReportField(500, true));
_columns.Add("FunctionalHead", new ReportField(50, false));
_columns.Add("AdditionalData", new ReportField(100, false));
_columns.Add("TOM", new ReportField(100, false));
_columns.Add("REN", new ReportField(100, false));
_columns.Add("Bcontrol Function Structure", new ReportField(100, false));
_columns.Add("Taxonomy Level 3", new ReportField(100, false));
_columns.Add("BusinessHierarchy1", new ReportField(100, false));
_columns.Add("BusinessHierarchy2", new ReportField(100, false));
_columns.Add("BusinessHierarchy3", new ReportField(100, false));
}
public void ShouldPassOnTheHintFromTheFirstHelpfulRule()
{
// Given an event aggregator to which we're subscribed
var events = new EventAggregator();
Hint hint = null;
events.GetEvent<HintProvidedEvent>().Subscribe(h => hint = h);
// And one rule which fails then one which passes first time
var unhelpfulRule = new Mock<IMightBeAbleToHelp>();
unhelpfulRule.Setup(r => r.HelpWith(It.IsAny<NineCells>())).Returns(Hint.None);
var expectedHint = new Hint("I can help!", new List<Cell>());
var helpfulRule = new Mock<IMightBeAbleToHelp>();
helpfulRule.Setup(r => r.HelpWith(It.IsAny<NineCells>())).Returns(expectedHint);
// And a repository with some cells in it
var repository = new Mock<ILookAfterCells>();
repository.Setup(r => r.FetchCellsByRowColumnOrNiner()).Returns(
new List<NineCells> {new NineCells(new Cell[0])});
// When we publish a request for a hint
new Solver(events, repository.Object, new[] {unhelpfulRule.Object, helpfulRule.Object});
events.GetEvent<HintRequestEvent>().Publish(null);
// Then the solver should publish the first helpful hint
Assert.AreEqual(expectedHint, hint);
}
public void A_valid_message_invokes_HandlerResultProcessing_when_expected_to() {
var eventAggregator = new EventAggregator();
var coroutineHandlerMock = new Mock<IHandleWithCoroutine<object>>();
var taskHandlerMock = new Mock<IHandleWithTask<object>>();
var coroutineHandlerProcessed = false;
var taskHandlerProcessed = false;
coroutineHandlerMock.Setup(handlerStub => handlerStub.Handle(It.IsAny<object>()))
.Returns(() => new List<IResult>());
taskHandlerMock.Setup(handlerStub => handlerStub.Handle(It.IsAny<object>()))
.Returns(() => new Task(() => { }));
EventAggregator.HandlerResultProcessing = (target, result) => {
if (target is IHandleWithCoroutine<object>) {
coroutineHandlerProcessed = true;
}
else if (target is IHandleWithTask<object>) {
taskHandlerProcessed = true;
}
};
eventAggregator.Subscribe(coroutineHandlerMock.Object);
eventAggregator.Subscribe(taskHandlerMock.Object);
eventAggregator.Publish(new object());
Assert.True(coroutineHandlerProcessed);
Assert.True(taskHandlerProcessed);
}
public void TryGetEventHandler_should_return_false_when_no_subscribers_exist()
{
var subject = new EventAggregator();
Action<int> handler;
subject.TryGetEventHandler(out handler).Should().BeFalse();
}
public void ShouldAskEachRuleInTurnWithNinersRowsAndColumnsUntilOnePasses()
{
// Given a repository with different rows, columns and niners
var niners = new List<NineCells> { new NineCells( new[] {new Cell(new CellId(-1, -1)) } )};
var rows = new List<NineCells> { new NineCells( new[] {new Cell(new CellId(-1, -1)) } )};
var columns = new List<NineCells>
{
new NineCells(new[] {new Cell(new CellId(-1, -1))} ),
new NineCells(new[] {new Cell(new CellId(-1, -1))} ),
new NineCells(new[] {new Cell(new CellId(-1, -1))} ),
};
var repository = new Mock<ILookAfterCells>();
var allSequences = new[] {niners, rows, columns}.SelectMany(list => list).ToArray();
repository.Setup(r => r.FetchCellsByRowColumnOrNiner()).Returns(allSequences);
// And one rule which fails then one which passes first time
var unhelpfulRule = new Mock<IMightBeAbleToHelp>();
unhelpfulRule.Setup(r => r.HelpWith(It.IsAny<NineCells>())).Returns(Hint.None);
var expectedHint = new Hint("I can help!", new List<Cell>());
var helpfulRule = new Mock<IMightBeAbleToHelp>();
helpfulRule.Setup(r => r.HelpWith(It.IsAny<NineCells>())).Returns(expectedHint);
// When we ask the solver for a hint
var events = new EventAggregator();
new Solver(events, repository.Object, new[] {unhelpfulRule.Object, helpfulRule.Object});
events.GetEvent<HintRequestEvent>().Publish(null);
// Then the first rule should be called with each niner, row and column
Array.ForEach(allSequences, s => unhelpfulRule.Verify(r => r.HelpWith(s)));
// And the second should only be called once
helpfulRule.Verify(r => r.HelpWith(It.IsAny<NineCells>()), Times.Once());
}
public async Task Navigate_To_Subsequent_Page_Back_Button_Visible()
{
await DispatcherHelper.ExecuteOnUIThread(() =>
{
var eventAggregator = new EventAggregator();
var frame = new FrameFacadeAdapter(new Frame(), eventAggregator);
var sessionStateService = new MockSessionStateService();
sessionStateService.GetSessionStateForFrameDelegate = (currentFrame) => new Dictionary<string, object>();
var navigationService = new FrameNavigationService(frame, (pageToken) => typeof(MockPage), sessionStateService);
var deviceGestureService = new DeviceGestureService(eventAggregator);
deviceGestureService.UseTitleBarBackButton = true;
var navigationManager = SystemNavigationManager.GetForCurrentView();
// Reset back button visibility before running, can't do this in TestInitialize because CoreWindow sometimes isn't ready
SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility = AppViewBackButtonVisibility.Collapsed;
Assert.AreEqual(AppViewBackButtonVisibility.Collapsed, navigationManager.AppViewBackButtonVisibility);
navigationService.Navigate("Mock", 1);
Assert.AreEqual(AppViewBackButtonVisibility.Collapsed, navigationManager.AppViewBackButtonVisibility);
navigationService.Navigate("Mock", 2);
Assert.AreEqual(AppViewBackButtonVisibility.Visible, navigationManager.AppViewBackButtonVisibility);
});
}
public async Task Navigate_Raises_NavigationStateChangedEvent()
{
var tcs = new TaskCompletionSource<bool>();
var eventAggregator = new EventAggregator();
eventAggregator.GetEvent<NavigationStateChangedEvent>().Subscribe((args) => tcs.SetResult(args.StateChange == StateChangeType.Forward));
await DispatcherHelper.ExecuteOnUIThread(() =>
{
var frame = new FrameFacadeAdapter(new Frame(), eventAggregator);
var sessionStateService = new MockSessionStateService();
sessionStateService.GetSessionStateForFrameDelegate = (currentFrame) => new Dictionary<string, object>();
var navigationService = new FrameNavigationService(frame, (pageToken) => typeof(MockPage), sessionStateService);
navigationService.Navigate("Mock", 1);
});
await Task.WhenAny(tcs.Task, Task.Delay(200));
if (tcs.Task.IsCompleted)
{
Assert.IsTrue(tcs.Task.Result);
}
else
{
Assert.Fail("NavigationStateChangedEvent event wasn't raised within 200 ms.");
}
}
static ServiceFactoryBase()
{
Events = new EventAggregator();
ResourceService = new ResourceService();
DialogService = new RealDialogService();
MessageBoxService = new RealMessageBoxService();
}
public MainViewModel()
{
var events = new EventAggregator();
var config = new Configuration(events: events).WithCss().WithDefaultLoader(m =>
{
m.IsNavigationEnabled = true;
m.IsResourceLoadingEnabled = true;
});
context = BrowsingContext.New(config);
profiler = new ProfilerViewModel(events);
errors = new ErrorsViewModel(events);
dom = new DOMViewModel();
query = new QueryViewModel();
repl = new ReplViewModel();
settings = new SettingsViewModel();
statistics = new StatisticsViewModel();
tree = new TreeViewModel();
sheets = new SheetViewModel();
cts = new CancellationTokenSource();
views = new ITabViewModel[]
{
dom,
query,
repl,
statistics,
tree,
sheets
};
logs = new IEventViewModel[]
{
profiler,
errors
};
}
static void Main(string[] args)
{
UnityContainer container = new UnityContainer();
container.RegisterInstance<IServiceLocator>(new UnityServiceLocatorAdapter(container));
container.RegisterType<IModuleInitializer, ModuleInitializer>();
TextLogger logger = new TextLogger();
container.RegisterInstance<ILoggerFacade>(logger);
IEventAggregator eventAggregator = new EventAggregator();
container.RegisterInstance<IEventAggregator>(eventAggregator);
ModuleCatalog catalog = new ModuleCatalog();
//catalog.AddModule(typeof(RFID.RFIDModule));
catalog.AddModule(typeof(BookInformation.BookInformationModule));
catalog.AddModule(typeof(BookLocation.BookLocationModule));
container.RegisterInstance<IModuleCatalog>(catalog);
container.RegisterType<IModuleManager, ModuleManager>();
IModuleManager manager = container.Resolve<IModuleManager>();
manager.Run();
//测试RFID服务模块的功能
//RFIDUnitTest.testRFID(container);
/******/
//测试串口服务的功能
//SerialUnitTest.testSerial(container);
//测试数据库功能
DatabaseUnitTest.testAllDatabase(container);
}
public static void Main(string[] args)
{
// Create the Prism event aggregator.
var prismEventAggregator = new EventAggregator();
// If you get an access denied error when running the demo, try this command line:
// netsh http add urlacl url=http://+:8700/MyUri user=DOMAIN\user
const string Url = "http://+:8700/";
// Register shims before WebApp.Start(). This ensures that the library's internal
// Hub is visible to the SignalR server.
PubSubSignalRServer.RegisterShims(new[]
{
new PrismEventAggregatorShim(prismEventAggregator),
});
using (WebApp.Start<OwinConfig>(Url))
{
// Fire up the test BLL that will use the event service to broadcast to client.
var myBusinessLogic = new MyBusinessLogic(prismEventAggregator);
Console.WriteLine("Server started. Press any key to stop...");
Console.ReadKey();
}
}
public Position()
{
RemoveFromCollectionCommand = new DelegateCommand(RemoveFromCollection);
GoToPositionCommand = new DelegateCommand(GoToPosition);
ea = ServiceLocator.Current.GetInstance<EventAggregator>();
ea.GetEvent<NewMicrostepResolutionEvent>()
.Subscribe(onMicrostepResolutionChanged, ThreadOption.BackgroundThread);
}
public QuoteGridViewModel()
{
this._gridList = new QuoteGridList();
_quoteupdateservice = ServiceLocator.Current.GetInstance<IQuoteUpdateService>() as QuoteUpdateService;
_eventaggregator = ServiceLocator.Current.GetInstance<EventAggregator>();
_quoteupdateservice.GridViewModel = this;
}
public PluginRuntime(IPluginPersister pluginPersister, EventAggregator eventAggregator, ITpBus bus)
{
_pluginPersister = pluginPersister;
_eventAggregator = eventAggregator;
_bus = bus;
_eventAggregator.Get<Event<AccountCollectionCreated>>().Subscribe(OnAccountCollectionCreated);
_eventAggregator.Get<Event<ProfileChanged>>().Subscribe(OnProfileChanged);
}
public void Setup()
{
_mockProducerBoundary = new Mock<SearchPlayersProducerBoundary>();
_mockConsumerBoundary = new Mock<SearchPlayersConsumerBoundary>();
_eventAggregator = new EventAggregatorImp();
_controller = new SearchPlayersController(_eventAggregator, _mockProducerBoundary.Object, _mockConsumerBoundary.Object);
}
public void TryGetEventHandler_should_return_true_when_one_subscriber_exists()
{
var subject = new EventAggregator();
subject.Subscribe<int>(x => { });
Action<int> handler;
subject.TryGetEventHandler(out handler).Should().BeTrue();
}
public SearchPlayersController(EventAggregator eventAggregator, SearchPlayersProducerBoundary producerBoundary, SearchPlayersConsumerBoundary consumerBoundary)
{
_eventAggregator = eventAggregator;
_producerBoundary = producerBoundary;
_consumerBoundary = consumerBoundary;
_eventAggregator.Subscribe<SearchPlayersRequest>(HandleSearchPlayersRequest);
}
public void GetReturnsSingleInstancesOfSameEventType()
{
var eventAggregator = new EventAggregator();
var instance1 = eventAggregator.GetEvent<MockEventBase>();
var instance2 = eventAggregator.GetEvent<MockEventBase>();
Assert.AreSame(instance2, instance1);
}
public void SetUp()
{
recordingLogger = new RecordingLogger();
events = new EventAggregator(() => recordingLogger, new IListener[0]);
handler = new StubMessage1Handler();
events.AddListener(handler);
}
public static void Main(string[] args)
{
Application.Init ();
EventAggregator appEvents = new EventAggregator ();
CalculatorStateManager stateManager = new CalculatorStateManager (appEvents);
MainWindow win = new MainWindow (appEvents);
win.Show ();
Application.Run ();
}
public static void Initialize(ILayoutService ILayoutService, ISecurityService ISecurityService)
{
Events = new EventAggregator();
ResourceService = new ResourceService();
Layout = ILayoutService;
SecurityService = ISecurityService;
LoginService = new LoginService(ClientType.Monitor, "Оперативная задача. Авторизация.");
SubscribeEvents();
}
public void Should_send_message()
{
var someMessageHandler = new SomeMessageHandler();
var eventAggregator = new EventAggregator();
eventAggregator.AddListener(someMessageHandler);
eventAggregator.SendMessage<SomeMessage>();
someMessageHandler.EventsTrapped.Count().ShouldEqual(1);
}
public static void Initialize(ILayoutService ILayoutService, ISecurityService ISecurityService)
{
ServiceFactoryBase.Events = Events = new EventAggregator();
ServiceFactoryBase.SecurityService = SecurityService = ISecurityService;
ResourceService = new ResourceService();
Layout = ILayoutService;
LoginService = new LoginService(ClientType.Monitor, "Оперативная задача. Авторизация.");
ContentService = new ContentService("Monitor");
}
public void BringDynamicPanelIntoView <TViewModel>(TViewModel viewModel)
{
viewModel.AssertNotNull(nameof(viewModel));
EventAggregator.GetEvent <BringDynamicPanelIntoViewRequest>().Publish(new BringDynamicPanelIntoViewArgs(typeof(TViewModel), viewModel));
}
public void BringStaticPanelIntoView <TViewModel>()
{
EventAggregator.GetEvent <BringStaticPanelIntoViewRequest>().Publish(new BringStaticPanelIntoViewArgs(typeof(TViewModel)));
}
private void OnChangeImage()
{
EventAggregator.GetEvent <ImageChangeRequestedEvent>().Publish(null);
}
public void GotoConnectionSetup()
{
EventAggregator.PublishOnUIThread(new ChangeMainModeEvent(MainMode.ConnectionSetup));
}
public ClientManager(
NetClient netClient,
ServerManager serverManager,
PacketManager packetManager,
UiManager uiManager,
Settings.GameSettings gameSettings,
ModSettings modSettings
)
{
_netClient = netClient;
_serverManager = serverManager;
_uiManager = uiManager;
_gameSettings = gameSettings;
_modSettings = modSettings;
_playerData = new Dictionary <ushort, ClientPlayerData>();
_playerManager = new PlayerManager(packetManager, gameSettings, _playerData);
_animationManager = new AnimationManager(netClient, _playerManager, packetManager, gameSettings);
_mapManager = new MapManager(netClient, gameSettings);
_entityManager = new EntityManager(netClient);
new PauseManager(netClient).RegisterHooks();
_commandManager = new ClientCommandManager();
var eventAggregator = new EventAggregator();
RegisterCommands();
var clientApi = new ClientApi(this, _commandManager, uiManager, netClient, eventAggregator);
_addonManager = new ClientAddonManager(clientApi);
ModHooks.FinishedLoadingModsHook += _addonManager.LoadAddons;
// Check if there is a valid authentication key and if not, generate a new one
if (!AuthUtil.IsValidAuthKey(modSettings.AuthKey))
{
modSettings.AuthKey = AuthUtil.GenerateAuthKey();
}
// Then authorize the key on the locally hosted server
serverManager.AuthorizeKey(modSettings.AuthKey);
// Register packet handlers
packetManager.RegisterClientPacketHandler <HelloClient>(ClientPacketId.HelloClient, OnHelloClient);
packetManager.RegisterClientPacketHandler <ServerClientDisconnect>(ClientPacketId.ServerClientDisconnect,
OnDisconnect);
packetManager.RegisterClientPacketHandler <PlayerConnect>(ClientPacketId.PlayerConnect, OnPlayerConnect);
packetManager.RegisterClientPacketHandler <ClientPlayerDisconnect>(ClientPacketId.PlayerDisconnect,
OnPlayerDisconnect);
packetManager.RegisterClientPacketHandler <ClientPlayerEnterScene>(ClientPacketId.PlayerEnterScene,
OnPlayerEnterScene);
packetManager.RegisterClientPacketHandler <ClientPlayerAlreadyInScene>(ClientPacketId.PlayerAlreadyInScene,
OnPlayerAlreadyInScene);
packetManager.RegisterClientPacketHandler <GenericClientData>(ClientPacketId.PlayerLeaveScene,
OnPlayerLeaveScene);
packetManager.RegisterClientPacketHandler <PlayerUpdate>(ClientPacketId.PlayerUpdate, OnPlayerUpdate);
packetManager.RegisterClientPacketHandler <EntityUpdate>(ClientPacketId.EntityUpdate, OnEntityUpdate);
packetManager.RegisterClientPacketHandler <GameSettingsUpdate>(ClientPacketId.GameSettingsUpdated,
OnGameSettingsUpdated);
packetManager.RegisterClientPacketHandler <ChatMessage>(ClientPacketId.ChatMessage, OnChatMessage);
// Register handlers for events from UI
uiManager.ConnectInterface.ConnectButtonPressed += Connect;
uiManager.ConnectInterface.DisconnectButtonPressed += () => Disconnect();
uiManager.SettingsInterface.OnTeamRadioButtonChange += InternalChangeTeam;
uiManager.SettingsInterface.OnSkinIdChange += InternalChangeSkin;
UiManager.InternalChatBox.ChatInputEvent += OnChatInput;
netClient.ConnectEvent += response => uiManager.OnSuccessfulConnect();
netClient.ConnectFailedEvent += uiManager.OnFailedConnect;
// Register the Hero Controller Start, which is when the local player spawns
On.HeroController.Start += (orig, self) => {
// Execute the original method
orig(self);
// If we are connect to a server, add a username to the player object
if (netClient.IsConnected)
{
_playerManager.AddNameToPlayer(
HeroController.instance.gameObject,
_username,
_playerManager.LocalPlayerTeam
);
}
};
// Register handlers for scene change and player update
UnityEngine.SceneManagement.SceneManager.activeSceneChanged += OnSceneChange;
On.HeroController.Update += OnPlayerUpdate;
// Register client connect and timeout handler
netClient.ConnectEvent += OnClientConnect;
netClient.TimeoutEvent += OnTimeout;
// Register application quit handler
ModHooks.ApplicationQuitHook += OnApplicationQuit;
}
protected override void OnInitialized()
{
base.OnInitialized();
EventAggregator.Subscribe(this);
}
public override void RunEffect()
{
EventAggregator.PublishT(GameEvent.AddTime, this, (int)Duration);
}
public MovementEditorViewModel(IBusyService busyService, IUnityContainer container, IMessageBoxService messageBoxService, IDesktopKeyEventHandler keyEventHandler, EventAggregator eventAggregator)
: base(busyService, container)
{
this.eventAggregator = eventAggregator;
this.messageBoxService = messageBoxService;
this.desktopKeyEventHandler = keyEventHandler;
InitializeCommands();
this.eventAggregator.GetEvent <EditMovementEvent>().Subscribe(this.LoadMovement);
this.eventAggregator.GetEvent <FinishedAbilityCollectionRetrievalEvent>().Subscribe(this.LoadReferenceResource);
this.eventAggregator.GetEvent <AttackInitiatedEvent>().Subscribe(this.AttackInitiated);
this.eventAggregator.GetEvent <AttackExecutionsFinishedEvent>().Subscribe(this.AttackEnded);
this.eventAggregator.GetEvent <PlayMovementConfirmedEvent>().Subscribe(this.PlayMovement);
this.eventAggregator.GetEvent <StopMovementEvent>().Subscribe(this.StopMovement);
// Unselect everything at the beginning
this.InitializeMovementSelections();
this.InitializeDesktopKeyEventHandlers();
}
public void PublishChanged()
{
EventAggregator.GetEvent <AccountChangedEvent>().Publish(this);
}
void _client_OnTradeUpdated(PTEntity.TradeUpdate obj)
{
string info = string.Format("trade: {0}\t{1}\t{2}", obj.InstrumentID, obj.Price, obj.TradeTime);
EventAggregator.GetEvent <TradeUpdatedEvent>().Publish(obj);
}
public PublishEventHandler(EventAggregator event_aggregator, RegionManager regionManager)
{
this.event_aggregator = event_aggregator;
region_manager = regionManager;
}
/// <summary>
/// 构造
/// </summary>
/// <param name="container"></param>
public LoginWindowViewModel(IContainerExtension container) : base(container)
{
EventAggregator.GetEvent <MainWindowLoadingEvent>().Subscribe(e => IsLoading = e);
EventAggregator.GetEvent <SignUpSuccessEvent>().Subscribe(signUpInfo => SignInTabItem.IsSelected = true);
}
public void Done()
{
var proxyConfig = _transportService.GetProxyConfig() as TLProxyConfig76 ?? TLProxyConfigBase.Empty as TLProxyConfig76;
if (proxyConfig == null)
{
return;
}
if (!IsDoneEnabled)
{
return;
}
if (IsSocks5Proxy)
{
TLSocks5Proxy proxy = null;
// new proxy
if (_proxy == null)
{
proxy = new TLSocks5Proxy {
CustomFlags = new TLLong(0)
};
proxy.Server = new TLString(Server);
var port = 0;
proxy.Port = int.TryParse(Port, out port) ? new TLInt(port) : new TLInt(0);
proxy.Username = new TLString(Username);
proxy.Password = new TLString(Password);
_proxy = proxy;
proxyConfig.Items.Add(_proxy);
proxyConfig.SelectedIndex = new TLInt(proxyConfig.Items.IndexOf(_proxy));
proxyConfig.IsEnabled = TLBool.True;
_transportService.SetProxyConfig(proxyConfig);
_transportService.Close();
MTProtoService.PingAsync(TLLong.Random(), result => { });
EventAggregator.Publish(new ProxyChangedEventArgs(proxyConfig));
NavigationService.GoBack();
return;
}
proxy = _proxy as TLSocks5Proxy;
// change type
if (proxy == null)
{
proxy = new TLSocks5Proxy {
CustomFlags = new TLLong(0)
};
proxy.Server = new TLString(Server);
var port = 0;
proxy.Port = int.TryParse(Port, out port) ? new TLInt(port) : new TLInt(0);
proxy.Username = new TLString(Username);
proxy.Password = new TLString(Password);
_proxy = proxy;
proxyConfig.Items.Add(_proxy);
proxyConfig.SelectedIndex = new TLInt(proxyConfig.Items.IndexOf(_proxy));
_transportService.SetProxyConfig(proxyConfig);
_transportService.Close();
MTProtoService.PingAsync(TLLong.Random(), result => { });
EventAggregator.Publish(new ProxyChangedEventArgs(proxyConfig));
NavigationService.GoBack();
return;
}
// same type
else
{
proxy.Server = new TLString(Server);
var port = 0;
proxy.Port = int.TryParse(Port, out port) ? new TLInt(port) : new TLInt(0);
proxy.Username = new TLString(Username);
proxy.Password = new TLString(Password);
_proxy = proxy;
if (proxyConfig.SelectedIndex.Value == proxyConfig.Items.IndexOf(_proxy))
{
_transportService.SetProxyConfig(proxyConfig);
_transportService.Close();
MTProtoService.PingAsync(TLLong.Random(), result => { });
}
EventAggregator.Publish(new ProxyChangedEventArgs(proxyConfig));
NavigationService.GoBack();
return;
}
}
else
{
TLMTProtoProxy proxy = null;
// new proxy
if (_proxy == null)
{
proxy = new TLMTProtoProxy {
CustomFlags = new TLLong(0)
};
proxy.Server = new TLString(Server);
var port = 0;
proxy.Port = int.TryParse(Port, out port) ? new TLInt(port) : new TLInt(0);
proxy.Secret = new TLString(Secret);
_proxy = proxy;
proxyConfig.Items.Add(_proxy);
proxyConfig.SelectedIndex = new TLInt(proxyConfig.Items.IndexOf(_proxy));
proxyConfig.IsEnabled = TLBool.True;
_transportService.SetProxyConfig(proxyConfig);
_transportService.Close();
MTProtoService.PingAsync(TLLong.Random(), result => { });
EventAggregator.Publish(new ProxyChangedEventArgs(proxyConfig));
NavigationService.GoBack();
return;
}
proxy = _proxy as TLMTProtoProxy;
// change type
if (proxy == null)
{
proxy = new TLMTProtoProxy {
CustomFlags = new TLLong(0)
};
proxy.Server = new TLString(Server);
var port = 0;
proxy.Port = int.TryParse(Port, out port) ? new TLInt(port) : new TLInt(0);
proxy.Secret = new TLString(Secret);
_proxy = proxy;
proxyConfig.Items.Add(_proxy);
proxyConfig.SelectedIndex = new TLInt(proxyConfig.Items.IndexOf(_proxy));
_transportService.SetProxyConfig(proxyConfig);
_transportService.Close();
MTProtoService.PingAsync(TLLong.Random(), result => { });
EventAggregator.Publish(new ProxyChangedEventArgs(proxyConfig));
NavigationService.GoBack();
return;
}
// same type
else
{
proxy.Server = new TLString(Server);
var port = 0;
proxy.Port = int.TryParse(Port, out port) ? new TLInt(port) : new TLInt(0);
proxy.Secret = new TLString(Secret);
_proxy = proxy;
if (proxyConfig.SelectedIndex.Value == proxyConfig.Items.IndexOf(_proxy))
{
_transportService.SetProxyConfig(proxyConfig);
_transportService.Close();
MTProtoService.PingAsync(TLLong.Random(), result => { });
}
EventAggregator.Publish(new ProxyChangedEventArgs(proxyConfig));
NavigationService.GoBack();
return;
}
}
}
protected void NotifyOthers(object value, OperationType operationType)
{
EventAggregator.NotifyOthers(value, operationType);
}
private void ReadCallback(IAsyncResult ar)
{
var connection = (SPClient)ar.AsyncState;
try
{
var readed = connection.Socket.EndReceive(ar, out var err);
if (err != SocketError.Success || readed <= 0)
{
connection.Socket.Disconnect(false);
connection.Socket.Close();
_connectionsPool.Release(connection);
return;
}
var buf = connection.WaitPacketLength;
var len = BitConverter.ToUInt16(buf, 0);
if (len > 0)
{
var packetDataBuffer = new byte[len];
var r = 0;
while (r < packetDataBuffer.Length)
{
r += connection.Socket.Receive(packetDataBuffer, r, packetDataBuffer.Length - r, SocketFlags.None);
}
ThreadPool.QueueUserWorkItem((callback) =>
{
var message = MessagePackSerializer.Deserialize <IMessageEvent>(packetDataBuffer);
switch (message)
{
case PublishEvent publish:
EventAggregator.Publish(publish.Channel, publish.Message.Data, publish.Message.Header, connection);
break;
case SubscribeEvent subscribe:
EventAggregator.Subscribe(subscribe.Channel, connection);
break;
case UnsubscribeEvent unsubsribe:
if (unsubsribe.FromAll)
{
EventAggregator.UnsubscribeFromAllChannels(connection);
}
else
{
EventAggregator.Unsubscribe(unsubsribe.Channel, connection);
}
break;
case RMINotyfiEvent rmiEvent:
RemoteMethodEventAggregator.Subscribe(connection, rmiEvent);
break;
case RemoteMethodEvent remoteEvent:
RemoteMethodEventAggregator.Publish(remoteEvent, connection);
break;
case ReplicationListUpdateEvent repListEvent:
ReplicationEventAggregator.DispatchGenericReplicationInfo(connection, repListEvent);
break;
case ReplicationNotyfiEvent repNotyfi:
ReplicationEventAggregator.SetReplicationInfo(connection, repNotyfi.ObjectsToReplicate);
break;
case ReplicationPrimitiveUpdateEvent primitiveUpdateEvent:
ReplicationEventAggregator.DispatchPrimitiveReplicationInfo(connection, primitiveUpdateEvent);
break;
}
});
}
else
{
connection.Socket.BeginReceive(connection.WaitPacketLength, 0, connection.WaitPacketLength.Length, SocketFlags.None, ReadCallback, connection);
return;
}
connection.Socket.BeginReceive(connection.WaitPacketLength, 0, connection.WaitPacketLength.Length, SocketFlags.None, ReadCallback, connection);
}
catch (ObjectDisposedException)
{
connection.ReadyForRMI = false;
}
catch (Exception e)
{
if (connection != null)
{
Disconnect(connection);
}
_log.Error(e);
}
}
/// <summary>
/// 执行关闭命令
/// </summary>
private void executeCancelCommand()
{
EventAggregator.GetEvent <ClosePopupEvent>().Publish(Parameter.FirstOrDefault(a => a.Key == ParentName).Value as MetroWindow);
}
public void SetUp()
{
serviceLocator = MockRepository.GenerateStub <IServiceLocator>();
eventAggregator = new EventAggregator(serviceLocator);
}
public void OnNavigatedFrom(Microsoft.Practices.Prism.Regions.NavigationContext navigationContext)
{
EventAggregator.GetEvent <MediaSelectionEvent>().Unsubscribe(imageView_MediaSelectionEvent);
}
public ProcessMonitor(ISystemService systemService, IPlayerService playerService, EventAggregator eventAggregator)
{
this.systemService = systemService;
this.playerService = playerService;
this.IsGw2Running = false;
this.DoesGw2HaveFocus = false;
this.currentMapId = -1;
this.isAdminRightsErrorShown = false;
this.eventAggregator = eventAggregator;
}
// -----
private void AddPerson()
{
EventAggregator.PublishOnUIThread(new ChangeViewMessage <PersonFormViewModel>());
}
public DialogsViewModel(ICacheService cacheService, ICommonErrorHandler errorHandler, IStateService stateService, INavigationService navigationService, IMTProtoService mtProtoService, ITelegramEventAggregator eventAggregator)
: base(cacheService, errorHandler, stateService, navigationService, mtProtoService, eventAggregator)
{
Items = new ObservableCollection <TLDialogBase>();
EventAggregator.Subscribe(this);
DisplayName = (string)new LowercaseConverter().Convert(AppResources.Dialogs, null, null, null);
Status = Items.Count == 0 && LazyItems.Count == 0 ? AppResources.Loading : string.Empty;
BeginOnThreadPool(() =>
{
var isAuthorized = SettingsHelper.GetValue <bool>(Constants.IsAuthorizedKey);
if (isAuthorized)
{
var dialogs = CacheService.GetDialogs();
var dialogsCache = new Dictionary <int, TLDialogBase>();
var clearedDialogs = new List <TLDialogBase>();
foreach (var dialog in dialogs)
{
if (!dialogsCache.ContainsKey(dialog.Index))
{
clearedDialogs.Add(dialog);
dialogsCache[dialog.Index] = dialog;
}
else
{
var cachedDialog = dialogsCache[dialog.Index];
if (cachedDialog.Peer is TLPeerUser && dialog.Peer is TLPeerUser)
{
CacheService.DeleteDialog(dialog);
continue;
}
if (cachedDialog.Peer is TLPeerChat && dialog.Peer is TLPeerChat)
{
CacheService.DeleteDialog(dialog);
continue;
}
}
}
// load cache
BeginOnUIThread(() =>
{
Status = dialogs.Count == 0 ? AppResources.Loading : string.Empty;
Items.Clear();
const int maxDialogSlice = 8;
for (var i = 0; i < clearedDialogs.Count && i < maxDialogSlice; i++)
{
Items.Add(clearedDialogs[i]);
}
if (maxDialogSlice < clearedDialogs.Count)
{
BeginOnUIThread(() =>
{
for (var i = maxDialogSlice; i < clearedDialogs.Count; i++)
{
Items.Add(clearedDialogs[i]);
}
UpdateItemsAsync(Telegram.Api.Constants.CachedDialogsCount);
});
}
else
{
UpdateItemsAsync(Telegram.Api.Constants.CachedDialogsCount);
}
});
}
});
}
private void OnUploadImge()
{
EventAggregator.GetEvent <ImageUploadRequestedEvent>().Publish(DoUploadImage);
}
internal LogWriter(Action <string> logMessage, EventAggregator eventAggregator)
{
_eventAggregator = eventAggregator;
_logMessage = logMessage;
}
protected override void Before_all_tests()
{
base.Before_all_tests();
_eventSubscriptionManager = EventAggregatorFactory.Create(_testLogger);
_statLightRunnerFactory = new StatLightRunnerFactory(_testLogger, _eventSubscriptionManager);
}
public SettingsRepository(ApplicationDbContextFactory contextFactory, EventAggregator eventAggregator)
{
_ContextFactory = contextFactory;
_EventAggregator = eventAggregator;
}
private void OnResetImage()
{
EventAggregator.GetEvent <ImageDownloadeEvent>().Publish(null);
}
public abstract void PublishEvent(EventAggregator aggregator, IScreenBase target);
public override void PublishEvent(EventAggregator aggregator, IScreenBase target)
{
aggregator.Publish(_event, _argsFactory(target));
}
void Start()
{
EventAggregator.Subscribe(GameEvent.EngGameProcess, this, Hide);
}
public void Handle(UploadableItem item)
{
var userSelf = item.Owner as TLUserSelf;
if (userSelf != null)
{
MTProtoService.UploadProfilePhotoAsync(
new TLInputFile
{
Id = item.FileId,
MD5Checksum = new TLString(MD5Core.GetHashString(item.Bytes).ToLowerInvariant()),
Name = new TLString(Guid.NewGuid() + ".jpg"),
Parts = new TLInt(item.Parts.Count)
},
new TLString(""),
new TLInputGeoPointEmpty(),
new TLInputPhotoCropAuto(),
photosPhoto =>
{
MTProtoService.GetFullUserAsync(new TLInputUserSelf(), userFull => { }, error => { });
},
error =>
{
});
return;
}
var channel = item.Owner as TLChannel;
if (channel != null)
{
if (channel.Id != null)
{
MTProtoService.EditPhotoAsync(
channel,
new TLInputChatUploadedPhoto
{
File = new TLInputFile
{
Id = item.FileId,
MD5Checksum = new TLString(MD5Core.GetHashString(item.Bytes).ToLowerInvariant()),
Name = new TLString("channelPhoto.jpg"),
Parts = new TLInt(item.Parts.Count)
},
Crop = new TLInputPhotoCropAuto()
},
statedMessage =>
{
var updates = statedMessage as TLUpdates;
if (updates != null)
{
var updateNewMessage = updates.Updates.FirstOrDefault(x => x is TLUpdateNewChannelMessage) as TLUpdateNewChannelMessage;
if (updateNewMessage != null)
{
EventAggregator.Publish(updateNewMessage.Message);
}
}
},
error =>
{
Execute.ShowDebugMessage("messages.editChatPhoto error " + error);
});
}
}
var chat = item.Owner as TLChat;
if (chat != null)
{
MTProtoService.EditChatPhotoAsync(
chat.Id,
new TLInputChatUploadedPhoto
{
File = new TLInputFile
{
Id = item.FileId,
MD5Checksum = new TLString(MD5Core.GetHashString(item.Bytes).ToLowerInvariant()),
Name = new TLString("chatPhoto.jpg"),
Parts = new TLInt(item.Parts.Count)
},
Crop = new TLInputPhotoCropAuto()
},
statedMessage =>
{
var updates = statedMessage as TLUpdates;
if (updates != null)
{
var updateNewMessage = updates.Updates.FirstOrDefault(x => x is TLUpdateNewMessage) as TLUpdateNewMessage;
if (updateNewMessage != null)
{
EventAggregator.Publish(updateNewMessage.Message);
}
}
},
error =>
{
Execute.ShowDebugMessage("messages.editChatPhoto error " + error);
});
}
}
public void SetupContext()
{
_eventSubscriptionManager = EventAggregatorFactory.Create(TestLogger);
Before_all_tests();
Because();
}
