protected NewMasterDataCommand(IMessageBroker messageBroker, IClientContext clientContext)
        {
            Text = () => LanguageData.General_New ;

            this.messageBroker = messageBroker;
            this.clientContext = clientContext;
        }

        public NewHouseCommand(IClientContext clientContext, IMessageBroker messageBroker)
        {
            Text = () => LanguageData.General_New;

            this.messageBroker = messageBroker;
            this.clientContext = clientContext;
        }

        public EmployeeCostEntryViewModel(
            IMessageBroker messageBroker, 
            IEmployeeCostService costService,
            IEmployeeService employeeService,
            SaveEmployeeCostCommand saveCostCommand,
            CancelCommand cancelCommand, ShowEmployeeCostCommand showListCommand
            )
        {
            this.messageBroker = messageBroker;
            this.costService = costService;
            this.employeeService = employeeService;
            ActualSaveCommand = saveCostCommand;

            CancelCommand = cancelCommand;
            ShowCostListCommand = showListCommand;
            InitializeCommands();
            NavigationCommands = new List<CommandBase>{SaveCommand,CancelCommand};
            CancelCommand.Action = broker => showListCommand.Execute(null);

            PropertiesToValidate = new List<string>()
            {
                "Date",
                "Total",
                "Details"
            };

            Employees = new ObservableCollection<Employee>(employeeService.GetAll());

            SubscribeMessages();
        }

        public SaveHenDepreciationCommand(IMessageBroker broker, IHenDepreciationService service)
        {
            Text = () => LanguageData.General_Save;

            this.broker = broker;
            this.service = service;
        }

        public SaveUsageCommand(IMessageBroker messageBroker, IConsumableUsageService usageService)
        {
            Text = () => LanguageData.General_Save;

            this.messageBroker = messageBroker;
            this.usageService = usageService;
        }

        public DeleteEggProductionCommand(IMessageBroker messageBroker, IEggProductionService costService)
        {
            Text = () => LanguageData.General_Delete;

            this.broker = messageBroker;
            this.service = costService;
        }

        public MasterDataViewModel(
            IMessageBroker messageBroker,
            Lazy<IHenListView> henListProxy,
            Lazy<IHenHouseListView> houseListProxy,
            Lazy<IEmployeeListView> employeeListProxy,
            Lazy<IConsumableListView> consumableListProxy,
            Lazy<IAdditionalCostListView> additionalCostListProxy,

            Lazy<IHenEntryView> henEntryProxy,
            Lazy<IHenHouseEntryView>  houseEntryProxy,
            Lazy<IEmployeeEntryView> employeeEntryProxy,
            Lazy<IConsumableEntryView> consumableEntryProxy,
            Lazy<IAdditionalCostEntryView> additionalCostEntryProxy 
            )
        {
            this.messageBroker = messageBroker;
            this.henListProxy = henListProxy;
            this.houseListProxy = houseListProxy;
            this.employeeListProxy = employeeListProxy;
            this.consumableListProxy = consumableListProxy;
            this.additionalCostListProxy = additionalCostListProxy;

            this.henEntryProxy = henEntryProxy;
            this.houseEntryProxy = houseEntryProxy;
            this.employeeEntryProxy = employeeEntryProxy;
            this.consumableEntryProxy = consumableEntryProxy;
            this.additionalCostEntryProxy = additionalCostEntryProxy;

            InitializeCommand();
            SetMessageListeners();
        }

 public GlimpseTraceWriter(IMessageBroker messageBroker, Func<IExecutionTimer> timerStrategy, ITraceWriter innerTraceWriter)
 {
   _messageBroker = messageBroker;
   _timerStrategy = timerStrategy;
   _innerTraceWriter = innerTraceWriter;
   _traceMessages = new List<JsonTraceMessage>();
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="InspectorContext" /> class.
        /// </summary>
        /// <param name="logger">The logger.</param>
        /// <param name="proxyFactory">The proxy factory.</param>
        /// <param name="messageBroker">The message broker.</param>
        /// <param name="timerStrategy">The timer strategy.</param>
        /// <param name="runtimePolicyStrategy">The runtime policy strategy.</param>
        /// <exception cref="System.ArgumentNullException">Throws an exception if any parameter if <c>null</c>.</exception>
        public InspectorContext(ILogger logger, IProxyFactory proxyFactory, IMessageBroker messageBroker, Func<IExecutionTimer> timerStrategy, Func<RuntimePolicy> runtimePolicyStrategy)
        {
            if (logger == null)
            {
                throw new ArgumentNullException("logger");
            }

            if (proxyFactory == null)
            {
                throw new ArgumentNullException("proxyFactory");
            }

            if (messageBroker == null)
            {
                throw new ArgumentNullException("messageBroker");
            }

            if (timerStrategy == null)
            {
                throw new ArgumentNullException("timerStrategy");
            }

            if (runtimePolicyStrategy == null)
            {
                throw new ArgumentNullException("runtimePolicyStrategy");
            }
            
            Logger = logger;
            ProxyFactory = proxyFactory;
            TimerStrategy = timerStrategy;
            MessageBroker = messageBroker;
            RuntimePolicyStrategy = runtimePolicyStrategy;
        }

        public UsageEntryViewModel(IMessageBroker messageBroker, IConsumableUsageService usageService,
            IHenHouseService houseService, IConsumableService consumableService,
            SaveUsageCommand saveUsageCommand, CancelCommand cancelCommand, ShowUsageCommand showListCommand
            )
        {
            this.messageBroker = messageBroker;
            this.usageService = usageService;
            this.houseService = houseService;
            this.consumableService = consumableService;

            this.saveUsageCommand = saveUsageCommand;
            this.showListCommand = showListCommand;

            CancelCommand = cancelCommand;

            PropertiesToValidate = new List<string>()
            {
                "Date",
                "Total",
                "Details"
            };

            InitializeCommands();

            HouseList = new ObservableCollection<HenHouse>(houseService.GetAll());
            ConsumableList = new ObservableCollection<Consumable>(consumableService.GetAll());

            SubscribeMessages();
        }

        public SaveEmployeeCostCommand(IMessageBroker broker, IEmployeeCostService costService)
        {
            Text = () => LanguageData.General_Save;

            this.broker = broker;
            this.costService = costService;
        }

        public DeleteEmployeeCostCommand(IMessageBroker messageBroker, IEmployeeCostService costService)
        {
            Text = () => LanguageData.General_Delete;

            this.broker = messageBroker;
            this.costService = costService;
        }

        public DeleteHenDepreciationCommand(IMessageBroker broker, IHenDepreciationService depreciationService)
        {
            Text = () => LanguageData.General_Delete;

            this.broker = broker;
            this.service = depreciationService;
        }

        public HenDepreciationEntryViewModel(IMessageBroker messageBroker, IHenDepreciationService service, IHenHouseService houseService,
            SaveHenDepreciationCommand saveCommand, CancelCommand cancelCommand, ShowHenDepreciationListCommand showListCommand)
        {
            this.broker = messageBroker;
            this.service = service;

            ActualSaveCommand = saveCommand;

            CancelCommand = cancelCommand;
            CancelCommand.Action = b => showListCommand.Execute(null);

            RefreshCommand = new DelegateCommand(p => OnRefresh(),p => true) {Text = () => LanguageData.General_Refresh};

            ShowListCommand = showListCommand;

            HenHouses = new ObservableCollection<HenHouse>(houseService.GetAll().OrderBy(h => h.Name));

            InitializeCommands();

            PropertiesToValidate = new List<string>
            {
                "Date",
                "Details"
            };

            NavigationCommands = new List<CommandBase>(){SaveCommand, CancelCommand, RefreshCommand};

            SubscribeMessages();
        }

 internal ApplicationContext(IImportPool importPool, IMessageBroker messageBroker, IServicePool servicePool, IDataBroker dataBroker, IVisualModuleManager visualModuleManager)
 {
     VisualModuleManager = visualModuleManager;
     DataBroker = dataBroker;
     ServicePool = servicePool;
     MessageBroker = messageBroker;
     ImportPool = importPool;
 }

        public ReportListView(ReportListViewModel model, IMessageBroker broker)
        {
            InitializeComponent();
            this.DataContext = model;
            this.model = model;
            this.broker = broker;

            SetEventHandlers();
        }

 public override INakedObjectAdapter Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, int resultPage, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager, IMessageBroker messageBroker, ITransactionManager transactionManager) {
     profileManager.Begin(session, ProfileEvent.ActionInvocation, identifier.MemberName, nakedObjectAdapter, lifecycleManager);
     try {
         return underlyingFacet.Invoke(nakedObjectAdapter, parameters, resultPage, lifecycleManager, manager, session, nakedObjectManager, messageBroker, transactionManager);
     }
     finally {
         profileManager.End(session, ProfileEvent.ActionInvocation, identifier.MemberName, nakedObjectAdapter, lifecycleManager);
     }
 }

 public NotificationsRegistry(IDocumentStore store,IMessageBroker broker,IEnumerable <IDocumentStore> orgStores)
 {
     Schedule(() => new NotificationProcessor(new EmailNotificationDispatcher(broker),
                                              new ToastDispatcher(store),
                                              orgStores
                        ).Process()).ToRunEvery(30).Seconds();
     
     
     
 }

    internal static void Initialize(Func<RuntimePolicy> runtimePolicyStrategy, Func<IExecutionTimer> timerStrategy, IMessageBroker messageBroker)
    {
      JsonSerializerSettingsFactory settingsFactory = new JsonSerializerSettingsFactory(
        JsonConvert.DefaultSettings,
        runtimePolicyStrategy,
        timerStrategy,
        messageBroker);

      JsonConvert.DefaultSettings = settingsFactory.GetDefaultSerializerSettings;
    }

 public TestObjectFactory(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectManager manager, ITransactionManager transactionManager, IServicesManager servicesManager, IMessageBroker messageBroker) {
     this.metamodelManager = metamodelManager;
     Session = session;
     this.lifecycleManager = lifecycleManager;
     this.persistor = persistor;
     this.manager = manager;
     this.transactionManager = transactionManager;
     this.servicesManager = servicesManager;
     this.messageBroker = messageBroker;
 }