public AccountsViewModel( ILoggerFacade logger, IStatusBar statusBar, IRegionManager regionManager, IEventAggregator eventAggregator, ITradingServiceAsync tradingService, UserContext userContext) { logger.Log("AccountsViewModel.AccountsViewModel()", Category.Debug, Priority.Low); _logger = logger; _statusBar = statusBar; _regionManager = regionManager; _eventAggregator = eventAggregator; _tradingService = tradingService; this.UserContext = userContext; _tradingService.OpenNewAccountCompleted += new EventHandler<OpenNewAccountCompletedEventArgs>(OpenNewAccountCallback); _tradingService.ChangeAccountNameCompleted += new EventHandler<AsyncCompletedEventArgs>(ChangeAccountNameCallback); CreateAccountCommand = new DelegateCommand<object>(this.CreateAccountExecute); EditAccountCommand = new DelegateCommand<object>(this.EditAccountExecute); UpdateAccountsCommand = new DelegateCommand<object>(this.UpdateAccountsExecute); SelectAccountCommand = new DelegateCommand<object>(this.SelectAccountExecute); SubscribeToEvents(); }
public ClientsViewModel(IEventAggregator aggregator, IRegionManager regionManager, IConnectionManager connectionManager, IInteractionService interactionService, ILoggerFacade loggerFacade) : base(aggregator, regionManager, connectionManager, interactionService, loggerFacade) { //aggregator.GetEvent<BootstrappingCompleteUiEvent>().Subscribe(BootstrappCompletedHandler); AdditionalRoomsValues = new ObservableCollection<string> {"Yes", "No"}; }
public ReservationDashBoardViewModel(IUnityContainer container, ILoggerFacade logger, IReservationManager reservationManager, ITableManager tableManager, IMessageBoxService messageBoxService, IDialogBoxService dialogBoxService) { this._logger = logger; this._container = container; this._reservationManager = reservationManager; this._tableManager = tableManager; this._messageBoxService = messageBoxService; this._dialogBoxService = dialogBoxService; this._reservationHours = new ObservableCollection<ReservationHour>(); this._reservations = new MappedValueCollection(); this.AddCommand = new DelegateCommand(this.OnAddCommand, () => { return this._noOfPersons > 0; }); this.BrowseCommand = new DelegateCommand(this.OnBrowseCommand); this.ImportCommand = new DelegateCommand(this.OnImportCommand, () => { return !string.IsNullOrEmpty(this._tableXMLFile); }); this._tables = this._tableManager.GetAll(); // Assumption : Reservation duration is between 10 Am and 10 Pm this._minFromHour = 10; this._maxFromHour = 22; for (int hour = this._minFromHour; hour <= this._maxFromHour; hour++) { this._reservationHours.Add(new ReservationHour(hour)); } this.FromHour = this._minFromHour; TableReservation.Common.ReservationsUpdatedEvent.Instance.Subscribe(this.ReservationsUpdated); this.ReservationsUpdated(Guid.NewGuid()); }
public MefModuleManager( IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade) : base(moduleInitializer, moduleCatalog, loggerFacade) { }
public TransferViewModel( ILoggerFacade logger, IStatusBar statusBar, IRegionManager regionManager, IEventAggregator eventAggregator, ITradingServiceAsync tradingService, Bullsfirst.InterfaceOut.Oms.MarketDataServiceReference.IMarketDataServiceAsync marketDataService, UserContext userContext, ReferenceData referenceData) { logger.Log("TransferViewModel.TransferViewModel()", Category.Debug, Priority.Low); _logger = logger; _statusBar = statusBar; _regionManager = regionManager; _eventAggregator = eventAggregator; _tradingService = tradingService; _marketDataService = marketDataService; this.UserContext = userContext; this.ReferenceData = referenceData; _tradingService.TransferCashCompleted += new EventHandler<AsyncCompletedEventArgs>(TransferCallback); _tradingService.TransferSecuritiesCompleted += new EventHandler<AsyncCompletedEventArgs>(TransferCallback); _tradingService.AddExternalAccountCompleted += new EventHandler<AddExternalAccountCompletedEventArgs>(AddExternalAccountCallback); _marketDataService.GetMarketPriceCompleted += new EventHandler<InterfaceOut.Oms.MarketDataServiceReference.GetMarketPriceCompletedEventArgs>(GetMarketPriceCallback); TransferCommand = new DelegateCommand<object>(this.TransferExecute, this.CanTransferExecute); AddExternalAccountCommand = new DelegateCommand<object>(this.AddExternalAccountExecute); this.PropertyChanged += this.OnPropertyChanged; this.ValidateAll(); SubscribeToEvents(); }
protected PrismUnityApplication(ILoggerFacade logger, IUnityContainer container) : base(logger) { if (container == null) throw new InvalidOperationException("Unity container is null"); Container = container; }
public OrdersViewModel( ILoggerFacade logger, IStatusBar statusBar, IEventAggregator eventAggregator, ITradingServiceAsync tradingService, UserContext userContext, ReferenceData referenceData) { logger.Log("PositionsViewModel.PositionsViewModel()", Category.Debug, Priority.Low); _logger = logger; _statusBar = statusBar; _eventAggregator = eventAggregator; _tradingService = tradingService; this.UserContext = userContext; this.Orders = new ObservableCollection<Order>(); this.ReferenceData = referenceData; this.UpdateOrdersCommand = new DelegateCommand<object>(this.UpdateOrdersExecute); this.ResetFilterCommand = new DelegateCommand<object>(this.ResetFilterExecute); this.CancelOrderCommand = new DelegateCommand<object>(this.CancelOrderExecute); _tradingService.GetOrdersCompleted += new EventHandler<GetOrdersCompletedEventArgs>(GetOrdersCallback); _tradingService.CancelOrderCompleted += new EventHandler<AsyncCompletedEventArgs>(CancelOrderCallback); this.UserContext.PropertyChanged += new PropertyChangedEventHandler(OnUserContextPropertyChanged); ResetFilter(); SubscribeToEvents(); }
public ReservationModule(IUnityContainer container, IRegionManager regionManager, IEventAggregator eventAggregator, ILoggerFacade logger) { this._container = container; this._regionManager = regionManager; this._eventAggregator = eventAggregator; this._logger = logger; }
/// <summary> /// Initializes a new instance of the <see cref="RosterViewModel"/> class. /// </summary> /// <param name="eventAggregator">The event aggregator.</param> /// <param name="logger">The logger.</param> /// <param name="rosterService">The roster service.</param> public RosterViewModel(IEventAggregator eventAggregator, ILoggerFacade logger, RosterService rosterService) { this.RosterService = rosterService; this.RegisterHandlers(); logger.Log("RosterViewModel Initialized", Category.Debug, Priority.None); }
public DataRepositoryObjectViewModel( IDataRepository dataRepository, IRegionManager regionManager, IInteractionService interactionService, ILoggerFacade logger ) : base(regionManager, interactionService, logger) { Model = null; InTransaction = false; this.DataRepository = dataRepository; }
public FoodItemViewModel( IDataRepository dataRepository, IRegionManager regionManager, IInteractionService interactionService, ILoggerFacade logger ) : base(dataRepository, regionManager, interactionService, logger) { FoodGroupsPerServing = new ObservableCollection<ServingViewModel<FoodGroup>>(); ValidFoodGroups = new AllFoodGroupsViewModel( dataRepository ); Title = DisplayStrings.NewFoodItemTitle; }
public CustomerListViewModel(IUnityContainer container) { this.container = container; this.logger = this.container.Resolve<ILoggerFacade>(); this.eventAggregator = this.container.Resolve<IEventAggregator>(); this.modelService = this.container.Resolve<IModelService>(); }
public BaseIOViewModel(SelectedSettings settings, string portName, ILoggerFacade logger) { this.logger = logger; this.settings = settings; this.portName = portName; StopCommand = new DelegateCommand(OnStop); }
/// <summary> /// Initializes a new instance of the <see cref="VMBase" /> class. /// </summary> /// <param name="aggregator">The aggregator.</param> /// <param name="regionManager">The region manager.</param> /// <param name="connectionManager"></param> /// <param name="interactionService"></param> /// <param name="loggerFacade"></param> /// <exception cref="System.ArgumentNullException"> /// Any parameter /// </exception> public ApplicationMenuViewModel(IEventAggregator aggregator, IRegionManager regionManager, IConnectionManager connectionManager, IInteractionService interactionService, ILoggerFacade loggerFacade) : base(aggregator, regionManager, connectionManager, interactionService, loggerFacade) { EventAggregator.GetEvent<UserAuthCompletedEvent>().Subscribe(OnUserAuth); }
public static ILoggerFacade InitLog4Net(string logName) { if (m_logger == null) { m_logger = new Log4NetLogger(logName); } return m_logger; }
public StatusBarViewModel(IEventAggregator eventAggregator, ILoggerFacade logger) { this.eventAggregator = eventAggregator; this.logger = logger; this.eventAggregator.GetEvent<SelectedSettingsEvent>().Subscribe(OnChangeSelectedSettings); this.eventAggregator.GetEvent<SettingsExceptionEvent>().Subscribe(OnSettingsException); }
public SortedModuleInitializer(IUnityContainer Container, ILoggerFacade Logger) { _logger = Logger; defaultInitializer = Container.Resolve<IModuleInitializer>("defaultModuleInitializer"); moduleConfigs = LoadModuleConfig(); Container.RegisterInstance<IModuleConfigs>("ModuleConfigs", moduleConfigs); }
public ModuleBModule(IRegionManager regionManager, ILoggerFacade logger) { _regionManager = regionManager; _logger = logger; _logger.Log("ModuleBModule.ctor() [done]", Category.Debug, Priority.Low); }
public TableManager(ILoggerFacade logger, ITableDataService tableDataService) { this._logger = logger; this._tableDataService = tableDataService; this._tableDataService.Serializer = new XmlSerializer(typeof(Table)); this._tableCollection = new ObservableCollection<Table>(); }
public LocationInputViewModel(CompositionContainer container, ILoggerFacade loggerFacade, IEventAggregator eventAggregator) { this.Street = string.Empty; this.Number = string.Empty; this.City = string.Empty; this.PostCode = string.Empty; this.OkCommand = new DelegateCommand<object>( this.OnOKClicked, this.CanOKClicked); this.CancelCommand = new DelegateCommand<object>( this.OnCancelClicked, this.CanCancelClicked); this.MoveDownStopCommand = new DelegateCommand<object>( this.OnMoveDownCommand, this.CanMoveDownCommand); this.MoveUpStopCommand = new DelegateCommand<object>( this.OnMoveUpCommand, this.CanMoveUpCommand); this.DeleteStopCommand = new DelegateCommand<object>( this.OnDeleteStopCommand, this.CanDeleteStopCommand); this._container = container; this._loggerFacade = loggerFacade; this.eventAggregator = eventAggregator; mainTabEvent = eventAggregator.GetEvent<CompositePresentationEvent<MainTabInfo>>(); _notificationErrorInteraction = new InteractionRequest<Notification>(); this.LocationSelectedCommand = new DelegateCommand<object>( this.OnLocationSelected, this.CanLocationSelected); this.StopSelectedCommand = new DelegateCommand<object>( this.OnStopSelected, this.CanStopSelected); this.LocationsSelected = new ObservableCollection<GeoLocatorDetail>(); this.LocationResults = new ObservableCollection<GeoLocatorDetail>(); this.RouteDirections = new ObservableCollection<string>(); this.SelectionVisibility = Visibility.Visible; this.StopsVisibility = Visibility.Collapsed; this.RouteDirectionsVisibility = Visibility.Collapsed; }
public ReservationManager(ILoggerFacade logger, IReservationDataService reservationDataService) { this._logger = logger; this._reservationDataService = reservationDataService; this._reservationDataService.Serializer = new XmlSerializer(typeof(Reservation)); this._reservationCollection = new ObservableCollection<Reservation>(); }
public DeleteWaypointDlgViewModel(IEventAggregator evtAggregator, ILoggerFacade logger) { _evtAggregator = evtAggregator; _logger = logger; _closeCommand = new DelegateCommand<FrameworkElement>(HandleCloseCmd); _deleteWpCommand = new DelegateCommand<FrameworkElement>(HandleDeleteCmd); }
protected BaseViewModel(ILoggerFacade logger) { Requires.NotNull(logger, "logger"); _logger = logger; Disposed = false; }
public TransactionHistoryViewModel( ILoggerFacade logger, IStatusBar statusBar, IEventAggregator eventAggregator, ITradingServiceAsync tradingService, UserContext userContext) { logger.Log("TransactionHistoryViewModel.TransactionHistoryViewModel()", Category.Debug, Priority.Low); _logger = logger; _statusBar = statusBar; _eventAggregator = eventAggregator; _tradingService = tradingService; this.UserContext = userContext; this.Transactions = new ObservableCollection<TransactionSummary>(); this.UpdateTransactionsCommand = new DelegateCommand<object>(this.UpdateTransactionsExecute); this.ResetFilterCommand = new DelegateCommand<object>(this.ResetFilterExecute); _tradingService.GetTransactionSummariesCompleted += new EventHandler<GetTransactionSummariesCompletedEventArgs>(GetTransactionSummariesCallback); this.UserContext.PropertyChanged += new PropertyChangedEventHandler(OnUserContextPropertyChanged); ResetFilter(); SubscribeToEvents(); }
public PlaylistProvider( ISession session, Dispatcher dispatcher, ILoggerFacade logger) { _session = session; _dispatcher = dispatcher; _logger = logger; _playlists = new ObservableCollection<Playlist>(); if (_session.PlaylistContainer != null) { InitializePlaylistContainer(); } else { _session.LoginComplete += (s, e) => { if (e.Status == Error.OK) { InitializePlaylistContainer(); } }; } }
public EmployeesViewModel(IUnityContainer container) { this.container = container; this.logger = this.container.Resolve<ILoggerFacade>(); this.eventAggregator = this.container.Resolve<IEventAggregator>(); this.modelService = this.container.Resolve<IModelService>(); SubmitCommand = new DelegateCommand(this.OnSubmit); }
public FileScheduler(SchedulerConfiguration configuration, ILoggerFacade logger) : base(configuration, logger) { if (this.logger != null) { this.logger.Log("FileScheduler is created.", Category.Info, Priority.High); } }
public SampleAddEditInstrumentView(IUnityContainer container, Ace2ApiServiceModule api, ILoggerFacade log, UiModel model, IEventAggregator eventAggregator) { InitializeComponent(); _vm = new SampleAddEditInstrumentViewModel(container, api, log, model, eventAggregator); this.DataContext = _vm; }
public SortedModuleInitializer(IUnityContainer container, ILoggerFacade logger, IEventAggregator eventAggregator) { _logger = logger; _eventAggregator = eventAggregator; DefaultInitializer = container.Resolve<IModuleInitializer>("defaultModuleInitializer"); ModuleConfigs = LoadModuleConfig(); container.RegisterInstance<IModuleConfigs>("ModuleConfigs", ModuleConfigs); }
public ModuleTracker(ILoggerFacade logger) { if( logger==null ) throw new ArgumentNullException("logger"); _logger = logger; InitializeModules(); }
public RecentFilesView( ILoggerFacade logger, [Import(typeof(IShellView), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] IShellView shellView, [Import(typeof(IUrakawaSession), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] IUrakawaSession session) { m_PropertyChangeHandler = new PropertyChangedNotifyBase(); m_PropertyChangeHandler.InitializeDependentProperties(this); m_Logger = logger; m_ShellView = shellView; m_Session = session; resetList(); DataContext = this; InitializeComponent(); intializeCommands(); }
public ChatViewModel(IUnityContainer container, IEventAggregator eventAggregator, ILoggerFacade logger, IRegionManager regionManager) { if (container == null || eventAggregator == null || logger == null || regionManager == null) { throw new ArgumentException(); } this._container = container; this._eventAggregator = eventAggregator; this._logger = logger; this._regionManager = regionManager; Messages = new ObservableCollection <Message>(); ButtonSend = new DelegateCommand(async() => { await this.ButtonSendClicked(); }); this._eventAggregator.GetEvent <MessageReceivedEvent>() .Subscribe(this.MessageReceivedEventHandler, ThreadOption.UIThread, false, this.MessageReceivedEventFilter); }
/// <summary> /// Constructor /// </summary> /// <param name="param">DashboardGadgetparam</param> public ViewModelIndexConstituents(DashboardGadgetParam param) { eventAggregator = param.EventAggregator; dbInteractivity = param.DBInteractivity; logger = param.LoggerFacade; PortfolioSelectionData = param.DashboardGadgetPayload.PortfolioSelectionData; EffectiveDate = param.DashboardGadgetPayload.EffectiveDate; lookThruEnabled = param.DashboardGadgetPayload.IsLookThruEnabled; if ((portfolioSelectionData != null) && (EffectiveDate != null) && IsActive) { dbInteractivity.RetrieveIndexConstituentsData(portfolioSelectionData, Convert.ToDateTime(effectiveDateInfo), lookThruEnabled, RetrieveIndexConstituentsDataCallbackMethod); BusyIndicatorStatus = true; } if (eventAggregator != null) { eventAggregator.GetEvent <PortfolioReferenceSetEvent>().Subscribe(HandlePortfolioReferenceSet); eventAggregator.GetEvent <EffectiveDateReferenceSetEvent>().Subscribe(HandleEffectiveDateSet); eventAggregator.GetEvent <LookThruFilterReferenceSetEvent>().Subscribe(HandleLookThruReferenceSetEvent); } }
public MenuBarPlugin( ILoggerFacade logger, IRegionManager regionManager //,[Import(typeof(IMenuBarView), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] //MenuBarView menuBarsView ) { m_Logger = logger; m_RegionManager = regionManager; //m_MenuBarView = menuBarsView; //m_RegionManager.RegisterViewWithRegion(RegionNames.MenuBar, typeof(IMenuBarView)); //IRegion targetRegion = m_RegionManager.Regions[RegionNames.MenuBar]; //targetRegion.Add(m_MenuBarView); //targetRegion.Activate(m_MenuBarView); //m_Logger.Log(@"MenuBar pushed to region", Category.Debug, Priority.Medium); }
public MovingAverageViewModel(WpfStrategy strategy, IHelperFactoryContainer iHelperFactoryContainer, Dispatcher UiDispatcher, ILoggerFacade logger) : base(strategy, iHelperFactoryContainer, UiDispatcher, logger) { var chartHelper = ServiceLocator.Current.GetInstance <IChartHelper>(); TimeFormatter = chartHelper.TimeFormatter; PriceFormatter = chartHelper.PriceFormatter; IsActive = false; IsLoadingTrades = true; IsLoadingOrderBook = true; cancellationTokenSource = new CancellationTokenSource(); tradeHelperFactory = HelperFactoryContainer.GetFactory <ITradeHelperFactory>(); orderBookHelperFactory = HelperFactoryContainer.GetFactory <IOrderBookHelperFactory>(); ShowCandlesticks = Strategy.StrategySubscriptions.Any(s => s.SubscribeCandlesticks); }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> /// <param name="loggerFacade">Logger used during the load and initialization of modules.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade) { if (moduleInitializer == null) { throw new ArgumentNullException(nameof(moduleInitializer)); } if (moduleCatalog == null) { throw new ArgumentNullException(nameof(moduleCatalog)); } if (loggerFacade == null) { throw new ArgumentNullException(nameof(loggerFacade)); } this.moduleInitializer = moduleInitializer; this.moduleCatalog = moduleCatalog; this.loggerFacade = loggerFacade; }
public DescriptionsViewModel( IEventAggregator eventAggregator, IUnityContainer container, ILoggerFacade logger, [Import(typeof(IUrakawaSession), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] IUrakawaSession session ) { m_EventAggregator = eventAggregator; m_Container = container; m_Logger = logger; m_UrakawaSession = session; ShowAdvancedEditor = false; m_EventAggregator.GetEvent <ProjectLoadedEvent>().Subscribe(OnProjectLoaded, ProjectLoadedEvent.THREAD_OPTION); m_EventAggregator.GetEvent <ProjectUnLoadedEvent>().Subscribe(OnProjectUnLoaded, ProjectUnLoadedEvent.THREAD_OPTION); m_EventAggregator.GetEvent <TreeNodeSelectionChangedEvent>().Subscribe(OnTreeNodeSelectionChanged, TreeNodeSelectionChangedEvent.THREAD_OPTION); }
public ValidatorAggregator( ILoggerFacade logger, IEventAggregator eventAggregator, [ImportMany(typeof(IValidator), RequiredCreationPolicy = CreationPolicy.Shared, AllowRecomposition = false)] IEnumerable <IValidator> validators, [Import(typeof(IUrakawaSession), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] IUrakawaSession session) { m_EventAggregator = eventAggregator; m_UrakawaSession = session; m_Logger = logger; foreach (IValidator validator in validators) { m_Validators.Add(validator); validator.ValidatorStateRefreshed += OnValidatorStateRefreshed; } //m_EventAggregator.GetEvent<ProjectLoadedEvent>().Subscribe(OnProjectLoaded, ProjectLoadedEvent.THREAD_OPTION); //m_EventAggregator.GetEvent<ProjectUnLoadedEvent>().Subscribe(OnProjectUnLoaded, ProjectUnLoadedEvent.THREAD_OPTION); }
public SqlCeDatabase(ILoggerFacade logger, DatabaseType databaseType = DatabaseType.SqlCe) : base(databaseType) { Logger = logger; if (_connection == null) { throw new Exception("not get a connection!"); } if (!_connection.IsConnected) { throw new Exception(GetConnectionBase().ErrorMsg); } RegisterColumnType(DbType.AnsiStringFixedLength, "NCHAR(255)"); RegisterColumnType(DbType.AnsiStringFixedLength, 4000, "NCHAR($l)"); RegisterColumnType(DbType.AnsiString, "NVARCHAR(255)"); RegisterColumnType(DbType.AnsiString, 4000, "NVARCHAR($l)"); RegisterColumnType(DbType.AnsiString, 1073741823, "NTEXT"); RegisterColumnType(DbType.Binary, "VARBINARY(8000)"); RegisterColumnType(DbType.Binary, 8000, "VARBINARY($l)"); RegisterColumnType(DbType.Binary, 1073741823, "IMAGE"); RegisterColumnType(DbType.Boolean, "BIT"); RegisterColumnType(DbType.Byte, "TINYINT"); RegisterColumnType(DbType.Currency, "MONEY"); RegisterColumnType(DbType.Date, "DATETIME"); RegisterColumnType(DbType.DateTime, "DATETIME"); RegisterColumnType(DbType.Decimal, "NUMERIC(19,5)"); RegisterColumnType(DbType.Decimal, 19, "NUMERIC($p, $s)"); RegisterColumnType(DbType.Double, "FLOAT"); RegisterColumnType(DbType.Guid, "UNIQUEIDENTIFIER"); RegisterColumnType(DbType.Int16, "SMALLINT"); RegisterColumnType(DbType.Int32, "INT"); RegisterColumnType(DbType.Int64, "BIGINT"); RegisterColumnType(DbType.Single, "REAL"); //synonym for FLOAT(24) RegisterColumnType(DbType.StringFixedLength, "NCHAR(255)"); RegisterColumnType(DbType.StringFixedLength, 4000, "NCHAR($l)"); RegisterColumnType(DbType.String, "NVARCHAR(255)"); RegisterColumnType(DbType.String, 4000, "NVARCHAR($l)"); RegisterColumnType(DbType.String, 1073741823, "NTEXT"); RegisterColumnType(DbType.Time, "DATETIME"); }
public Dataflow( ExportFactory <IFileSystem> fileSystemFactory, ILoggerFacade logger) { this._logger = logger; this._fileSystemFactory = fileSystemFactory; var parallelBlockOptions = new ExecutionDataflowBlockOptions { BoundedCapacity = 10, MaxDegreeOfParallelism = Math.Max(1, Environment.ProcessorCount - 1) }; var linkOptions = new DataflowLinkOptions { PropagateCompletion = true }; // create the dataflow blocks var readFileBlock = new TransformBlock <string, Tuple <string, string[]> >(filePath => ReadFileContents(filePath), parallelBlockOptions); var breakIntoSectionsBlock = new TransformManyBlock <Tuple <string, string[]>, FileSection>(fileInfo => BreakIntoSections(fileInfo), parallelBlockOptions); var printBlock = new ActionBlock <FileSection>( section => PrintResults(section), new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 1 }); InputBlock = readFileBlock; Completion = printBlock.Completion; // link dataflow blocks together readFileBlock.LinkTo(breakIntoSectionsBlock, linkOptions); breakIntoSectionsBlock.LinkTo(printBlock, linkOptions); // debug task completion DebugCompletion(readFileBlock, "Read File Block"); DebugCompletion(breakIntoSectionsBlock, "Break Into Sections Block"); DebugCompletion(printBlock, "Print Block"); }
public FriendsViewModel(ILoggerFacade logger, IRegionManager regionManager, IEventAggregator eventAggregator, ICollectFriendsService collectFriendsService, IGetRoomInfoService getRoomInfoService, IFriendsMainViewModel friendsMainViewModel) { if (null == logger) { throw new ArgumentNullException("logger"); } if (null == regionManager) { throw new ArgumentNullException("regionManager"); } if (null == eventAggregator) { throw new ArgumentNullException("eventAggregator"); } if (null == collectFriendsService) { throw new ArgumentNullException("collectFriendsService"); } if (null == getRoomInfoService) { throw new ArgumentNullException("getRoomInfoService"); } if (null == friendsMainViewModel) { throw new ArgumentNullException("friendsMainViewModel"); } this.m_Logger = logger; this.m_RegionManager = regionManager; this.m_EventAggregator = eventAggregator; this.m_CollectFriendsService = collectFriendsService; this.m_GetRoomInfoService = getRoomInfoService; this.FriendsMainViewModel = friendsMainViewModel; this.NavigateToForwardCommand = new DelegateCommand(ExecuteNavigateToForwardCommand); this.ItemDoubleClickedCommand = new DelegateCommand <Friend>(ExecuteItemDoubleClickedCommand); Task.Run(() => m_CollectFriendsService.CollectFriends(AuthRepository.MQKeyInfo.UserSid, friendsMainViewModel.Friends)); }
public DescriptionsNavigationPlugin( ILoggerFacade logger, IRegionManager regionManager, [Import(typeof(IUrakawaSession), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] IUrakawaSession session, [Import(typeof(IShellView), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] IShellView shellView, [Import(typeof(DescriptionsNavigationView), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] DescriptionsNavigationView pane, [Import(typeof(DescriptionsNavigationViewModel), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] DescriptionsNavigationViewModel viewModel ) { m_Logger = logger; m_RegionManager = regionManager; m_UrakawaSession = session; m_ShellView = shellView; m_DescriptionsNavView = pane; m_DescriptionsNavViewModel = viewModel; // Remark: using direct access instead of delayed lookup (via the region registry) // generates an exception, because the region does not exist yet (see "parent" plugin constructor, RegionManager.SetRegionManager(), etc.) m_RegionManager.RegisterNamedViewWithRegion(RegionNames.NavigationPaneTabs, new PreferredPositionNamedView { m_viewInstance = m_DescriptionsNavView, m_viewName = @"ViewOf_" + RegionNames.NavigationPaneTabs + @"_Descriptions", m_viewPreferredPosition = PreferredPosition.Last }); //m_RegionManager.RegisterViewWithRegion(RegionNames.NavigationPaneTabs, typeof(IDescriptionsNavigationView)); //IRegion targetRegion = m_RegionManager.Regions[RegionNames.NavigationPaneTabs]; //targetRegion.Add(m_DescriptionsNavView); //targetRegion.Activate(m_DescriptionsNavView); //m_Logger.Log(@"Navigation pane plugin initializing...", Category.Debug, Priority.Medium); }
public HeadingPaneViewModel( IEventAggregator eventAggregator, ILoggerFacade logger, [Import(typeof(IShellView), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] IShellView view, [Import(typeof(IUrakawaSession), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] IUrakawaSession session) { //Container = container; m_EventAggregator = eventAggregator; m_Logger = logger; m_ShellView = view; m_session = session; intializeCommands(); m_EventAggregator.GetEvent <ProjectLoadedEvent>().Subscribe(onProjectLoaded, ProjectLoadedEvent.THREAD_OPTION); m_EventAggregator.GetEvent <ProjectUnLoadedEvent>().Subscribe(onProjectUnLoaded, ProjectUnLoadedEvent.THREAD_OPTION); m_EventAggregator.GetEvent <TreeNodeSelectionChangedEvent>().Subscribe(OnTreeNodeSelectionChanged, TreeNodeSelectionChangedEvent.THREAD_OPTION); }
public ChatSplitViewModel(IRegionManager regionManager, IEventAggregator eventAggregator, ILoggerFacade logger, HubConnection connection) { if (regionManager == null || eventAggregator == null || logger == null || connection == null) { throw new ArgumentException(); } this._regionManager = regionManager; this._eventAggregator = eventAggregator; this._logger = logger; this._connection = connection; // Set as RegionContext in order to make the connection available to all // other hostet child views. this._regionManager.Regions[MainWindowRegionNames.MAIN_REGION].Context = connection; this._connection.Closed += this.WebsocketConnectionLost; this._connection.On("PongAsync", this.HandleResponse); this._connection.On <Message>("ReceiveMessageAsync", this.HandleReceiveMessage); }
private async Task DoExecuteAsync(Func <CancellationToken, Task> taskFunc, ILoggerFacade logger, TaskContext tc, CancellationToken ct) { try { await ct.TimeoutAsync(taskFunc, tc.MillisecondsTimeout); } catch (TimeoutException) { LogTimeout(logger, tc); throw; } catch (CallerOperationTimeoutException) { LogCallerTimeout(logger, tc); throw; } catch (OperationCanceledByCallerException) { LogCallerCancel(logger, tc); throw; } }
public SearchViewModel(IServiceProxy services, ILoggerFacade logger, IEventAggregator eventAggregator) { if (services == null) { throw new ArgumentNullException("services"); } if (logger == null) { throw new ArgumentNullException("logger"); } if (eventAggregator == null) { throw new ArgumentNullException("eventAggregator"); } this.services = services; this.logger = logger; this.eventAggregator = eventAggregator; SearchResults = new ObservableCollection <Customer>(); SearchCommand = new RelayCommand(SearchCommandOnExecute, SearchCommandCanExecute); }
public HomeViewModel(IServiceProxy services, ILoggerFacade logger, IEventAggregator eventAggregator) { if (services == null) { throw new ArgumentNullException("services"); } if (logger == null) { throw new ArgumentNullException("logger"); } if (eventAggregator == null) { throw new ArgumentNullException("eventAggregator"); } this.services = services; this.logger = logger; this.eventAggregator = eventAggregator; RefreshCommand = new RelayCommand(RefreshCommandOnExecute, RefreshCommandCanExecute); this.LoadStats(); }
/// <summary> /// 构造 /// </summary> /// <param name="container"></param> /// <param name="dsconfig"></param> protected ModuleBase(IApplicationContext container, IDsConfigurationSection dsconfig) { //#if DEBUG // Debugger.Launch(); //#endif logger = new LoggerFacade(this.GetType()); DsConfigurationManager dcm = new DsConfigurationManager(); Assembly a = this.GetType().Assembly; string contextName = a.GetName().Name.ToLower(); ParentContaioner = container; //初始化环境信息 this.InitializationDsEnvironment(dsconfig, a.FullName); logger.Debug("{0} Plug-ins start loading".FormatString(AddinInfo.AddinName)); //SyncInfo(dcm); if (File.Exists(AddinInfo.ConfigurationFilePath)) { System.Configuration.Configuration ecs = dcm.Get <System.Configuration.Configuration>(AddinInfo.ConfigurationFilePath); if (ecs == null) { logger.Error("{0} Configuration file loading exception, configuration file does not exist!".FormatString(AddinInfo.AddinName)); } CurrentAddinConfiguration = ecs; this.DsConfigurationSection = dsconfig; AddinConfigurationList.TryAdd(AddinInfo.AddinName, ecs); ParentContaioner.RegisterInstance(this); Container = ChildContainer.Create(container, contextName, ecs); GlobalObject.SetAddinContanier(AddinInfo.AddinName, Container); //初始化WCF服务 WCFServiceContainer.Create(contextName, CurrentAddinConfiguration); //初始化Socket服务 SocketServiceContainer.Create(CurrentAddinConfiguration); } logger.Debug("{0} Plug-in loaded".FormatString(AddinInfo.AddinName)); }
/// <summary> /// Constructor of the class that initializes various objects /// </summary> /// <param name="param">MEF Eventaggrigator instance</param> public ViewModelPerformanceGadget(DashboardGadgetParam param) { dbInteractivity = param.DBInteractivity; logger = param.LoggerFacade; eventAggregator = param.EventAggregator; portfolioSelectionData = param.DashboardGadgetPayload.PortfolioSelectionData; effectiveDate = param.DashboardGadgetPayload.EffectiveDate; country = param.DashboardGadgetPayload.HeatMapCountryData; selectedPeriod = param.DashboardGadgetPayload.PeriodSelectionData; if (effectiveDate != null && portfolioSelectionData != null && selectedPeriod != null && IsActive) { dbInteractivity.RetrievePerformanceGraphData(portfolioSelectionData, Convert.ToDateTime(effectiveDate), selectedPeriod, "NoFiltering", RetrievePerformanceGraphDataCallBackMethod); } if (eventAggregator != null) { eventAggregator.GetEvent <PortfolioReferenceSetEvent>().Subscribe(HandlePortfolioReferenceSet, false); eventAggregator.GetEvent <EffectiveDateReferenceSetEvent>().Subscribe(HandleEffectiveDateSet, false); eventAggregator.GetEvent <PeriodReferenceSetEvent>().Subscribe(HandlePeriodReferenceSet, false); eventAggregator.GetEvent <HeatMapClickEvent>().Subscribe(HandleCountrySelectionDataSet, false); } }
public SettingsAggregator( ILoggerFacade logger, IEventAggregator eventAggregator, [ImportMany(typeof(ISettingsProvider), RequiredCreationPolicy = CreationPolicy.Shared, AllowRecomposition = false)] IEnumerable <ISettingsProvider> settingsProviders) { m_EventAggregator = eventAggregator; m_Logger = logger; m_SettingsProviders = settingsProviders; if (Tobi.Common.Settings.Default.UpgradeSettings) { UpgradeAll(); Tobi.Common.Settings.Default.UpgradeSettings = false; } // Make sure we mark all the settings so that they all show in persistant storage next time we save. MarkAllAsChanged(); SaveAll(); }
public HeadingPanelView( IEventAggregator eventAggregator, ILoggerFacade logger, [Import(typeof(IUrakawaSession), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] IUrakawaSession urakawaSession, [Import(typeof(HeadingPaneViewModel), RequiredCreationPolicy = CreationPolicy.Shared, AllowDefault = false)] HeadingPaneViewModel viewModel) { m_UrakawaSession = urakawaSession; m_EventAggregator = eventAggregator; m_Logger = logger; m_ViewModel = viewModel; DataContext = m_ViewModel; m_ignoreTreeNodeSelectedEvent = false; //m_ignoreHeadingSelected = false; InitializeComponent(); m_ViewModel.SetView(this); }
public CoreRadio( [Import("CorePlayer")] ITrackPlayer corePlayer, IDocumentStore documentStore, ILoadingIndicatorService loadingIndicatorService, IToastService toastService, ILoggerFacade logger, Dispatcher dispatcher) { _trackQueuePublic = new ObservableCollection <Track>(); _trackStreamQueuePublic = new ObservableCollection <ITrackStream>(); _trackStreamQueue = new ConcurrentQueue <ITrackStream>(); _trackQueue = new ConcurrentQueue <Track>(); _corePlayer = corePlayer; _documentStore = documentStore; _loadingIndicatorService = loadingIndicatorService; _toastService = toastService; _logger = logger; _dispatcher = dispatcher; _corePlayer.Volume = 0.2; _corePlayer.TrackComplete += OnTrackComplete; _corePlayer.Initialize(); }
public ViewModelLoginForm(IManageLogins manageLogins, IManageSessions manageSessions, IRegionManager regionManager, ILoggerFacade logger) { _manageLogins = manageLogins; _manageSessions = manageSessions; _regionManager = regionManager; _logger = logger; //try //{ // if (_manageSessions != null) // { // #region GetSession Service Call // _manageSessions.GetSession((result) => // { // string methodNamespace = String.Format("{0}.{1}", GetType().FullName, System.Reflection.MethodInfo.GetCurrentMethod().Name); // if (result != null) // { // try // { // Session session = result as Session; // Logging.LogMethodParameter(_logger, methodNamespace, result.ToString(), 1, result.UserName); // Logging.LogSessionClose(_logger, result.UserName); // } // catch (Exception ex) // { // Prompt.ShowDialog("Message: " + ex.Message + "\nStackTrace: " + Logging.StackTraceToString(ex), "Exception", MessageBoxButton.OK); // Logging.LogException(_logger, ex); // } // } // }); // #endregion // } //} //catch (Exception ex) //{ // Prompt.ShowDialog("Message: " + ex.Message + "\nStackTrace: " + Logging.StackTraceToString(ex), "Exception", MessageBoxButton.OK); // Logging.LogLoginException(_logger, ex); //} }
public QuoteDispatcherService(IQuoteUpdateService quoteviewupdateservvice, IStrategyQuoteFeedService feedstrategyquoteservice, TickArchiver tickarchiveservice, ILoggerFacade logger, BlockingCollection <Tick> tickqueue) { this._quoteviewupdateservice = quoteviewupdateservvice; this._feedstrategyquoteservice = feedstrategyquoteservice; this._tickarchiveservice = tickarchiveservice; this._tickqueue = tickqueue; this._logger = logger; ConfigManager conf = Microsoft.Practices.ServiceLocation.ServiceLocator.Current.GetInstance <IConfigManager>() as ConfigManager; sampletime_ = conf.TickSampleTime; IObservable <MyEventArgs <Tick> > tickObservable = System.Reactive.Linq.Observable.FromEvent <MyEventArgs <Tick> >( h => TickReceived += h, h => TickReceived -= h); // only select trade // .BufferWithTime(TimeSpan.FromMilliseconds(_od)) // .Where(x => x.Count > 0) // .Subscribe(DataReceived, LogError); tickObservable.Where(e => e.Value.IsTrade).GroupBy(e => e.Value.FullSymbol) .Subscribe(group => group.Sample(TimeSpan.FromSeconds(sampletime_)) .Subscribe(QuoteDispatcher)); }
public static void LogBeginMethod(ILoggerFacade logger, string methodNamespace, string userName = "") { if (userName == "") { if (logger != null && SessionManager.SESSION != null) { logger.Log("|User[(" + SessionManager.SESSION.UserName.Replace(Environment.NewLine, " ") + ")]|Type[(BeginMethod" + ")]|MethodNameSpace[(" + methodNamespace.Replace(Environment.NewLine, " ") + ")]|TimeStamp[(" + DateTime.Now.ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss,fff").Replace(Environment.NewLine, " ") + ")]", Category.Info, Priority.None); } } else { logger.Log("|User[(" + userName.Replace(Environment.NewLine, " ") + ")]|Type[(BeginMethod" + ")]|MethodNameSpace[(" + methodNamespace.Replace(Environment.NewLine, " ") + ")]|TimeStamp[(" + DateTime.Now.ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss,fff").Replace(Environment.NewLine, " ") + ")]", Category.Info, Priority.None); } }
public LoginViewModel(ILoggerFacade logger, IUnityContainer unityContainer, IRegionManager regionManager, IEventAggregator eventAggregator, ITrackSuccessConnectionService trackService) { if (null == logger) { throw new ArgumentNullException("logger"); } if (null == unityContainer) { throw new ArgumentNullException("unityContainer"); } if (null == regionManager) { throw new ArgumentNullException("regionManager"); } if (null == eventAggregator) { throw new ArgumentNullException("eventAggregator"); } if (null == trackService) { throw new ArgumentNullException("trackService"); } this.m_Logger = logger; this.m_UnityContainer = unityContainer; this.m_RegionManager = regionManager; this.m_EventAggregator = eventAggregator; this.LoginModel = new LoginModel(); this.LoginCommand = new DelegateCommand <UIElement>(ExecuteLogin, CanExecuteLogin); this.TextChangedCommand = new DelegateCommand(ExecuteTextChanged); this.NavigateToCommand = new DelegateCommand <Uri>(ExecuteNavigateTo); this.InitialFocusCommand = new DelegateCommand <UIElement>(ExecuteInitialFocusCommand); this.InitialLoadedCommand = new DelegateCommand <SmoothBusyIndicator>(ExecuteInitialLoadedCommand); this.NavigateRequiredInfoViewCommand = new DelegateCommand(ExecuteNavigateRequiredInfoViewCommand); this.ConnectedIdentifications = trackService.GetListOfSuccessConnections(); }
public ViewDashboard(IManageDashboard manageDashboard, ILoggerFacade logger, IEventAggregator eventAggregator, IDBInteractivity dbInteractivity, IRegionManager regionManager) { InitializeComponent(); //Initialize MEF singletons this.eventAggregator = eventAggregator; this.manageDashboard = manageDashboard; this.logger = logger; this.dbInteractivity = dbInteractivity; this.regionManager = regionManager; //Subscribe to MEF Events eventAggregator.GetEvent <DashboardGadgetSave>().Subscribe(HandleDashboardGadgetSave); eventAggregator.GetEvent <DashboardGadgetLoad>().Subscribe(HandleDashboardGadgetLoad); eventAggregator.GetEvent <DashboardTileViewItemAdded>().Subscribe(HandleDashboardTileViewItemAdded); //Check for Empty Dashboard this.rtvDashboard.LayoutUpdated += (se, e) => { this.txtNoGadgetMessage.Visibility = this.rtvDashboard.Items.Count == 0 ? Visibility.Visible : Visibility.Collapsed; this.rtvDashboard.Visibility = this.rtvDashboard.Items.Count == 0 ? Visibility.Collapsed : Visibility.Visible; for (int index = 0; index < rtvDashboard.Items.Count; index++) { (rtvDashboard.Items[index] as RadTileViewItem).Opacity = (rtvDashboard.Items[index] as RadTileViewItem).TileState == TileViewItemState.Minimized ? 0.5 : 1; } }; this.rtvDashboard.TileStateChanged += (se, e) => { if (this.rtvDashboard.Items.Count == 1) { if ((e.Source as RadTileViewItem).TileState != TileViewItemState.Maximized) { (e.Source as RadTileViewItem).TileState = TileViewItemState.Maximized; } } }; }
internal FrameFacade(Frame frame, INavigationService navigationService, string id) { _frame = frame; _frame.ContentTransitions = new TransitionCollection { new NavigationThemeTransition() }; _frame.RegisterPropertyChangedCallback(Frame.CanGoBackProperty, (s, p) => CanGoBackChanged?.Invoke(this, EventArgs.Empty)); _frame.RegisterPropertyChangedCallback(Frame.CanGoForwardProperty, (s, p) => CanGoForwardChanged?.Invoke(this, EventArgs.Empty)); _dispatcher = frame.Dispatcher; _syncContext = SynchronizationContext.Current; _navigationService = navigationService; _logger = ApplicationTemplate.Current.Container.Resolve <ILoggerFacade>(); if (id != null) { Id = id; } }
/// <summary> /// Run the bootstrapper process. /// </summary> /// <param name="useDefaultConfiguration">If <see langword="true"/>, registers default Composite Application Library services in the container. This is the default behavior.</param> public void Run(bool useDefaultConfiguration) { _useDefaultConfiguration = useDefaultConfiguration; ILoggerFacade logger = LoggerFacade; if (logger == null) { throw new InvalidOperationException(Resources.NullLoggerFacadeException); } logger.Log("Creating Unity container", Category.Debug, Priority.Low); Container = CreateContainer(); if (Container == null) { throw new InvalidOperationException(Resources.NullUnityContainerException); } logger.Log("Configuring container", Category.Debug, Priority.Low); ConfigureContainer(); logger.Log("Configuring region adapters", Category.Debug, Priority.Low); ConfigureRegionAdapterMappings(); logger.Log("Creating shell", Category.Debug, Priority.Low); DependencyObject shell = CreateShell(); if (shell != null) { RegionManager.SetRegionManager(shell, Container.Resolve <IRegionManager>()); } logger.Log("Initializing modules", Category.Debug, Priority.Low); InitializeModules(); logger.Log("Bootstrapper sequence completed", Category.Debug, Priority.Low); }
public static ChartValues <T> GetNewTradesChart <T>( IEnumerable <ITrade> tradesUpdate, Func <ITrade, T> create, int tradesChartDisplayCount, ILoggerFacade logger) where T : TradeBase, new() { ChartValues <T> tradesChart; var sw = new Stopwatch(); sw.Start(); logger.Log($"Start GetTradesChart<{typeof(T).Name}>", Category.Info, Priority.Low); // Order by oldest to newest (as it will appear in the chart). var newTrades = (from t in tradesUpdate orderby t.Time, t.Id select create(t)).ToList(); var newTradesCount = newTrades.Count; if (newTradesCount > tradesChartDisplayCount) { // More new trades than the chart can take, only takes the newest trades. var chartTrades = newTrades.Skip(newTradesCount - tradesChartDisplayCount).ToList(); tradesChart = new ChartValues <T>(chartTrades); } else { // New trades less (or equal) the // total trades to show in the chart. tradesChart = new ChartValues <T>(newTrades); } sw.Stop(); logger.Log($"End GetTradesChart<{typeof(T).Name}> {sw.Elapsed}", Category.Info, Priority.Low); return(tradesChart); }