public SearchResultsPageViewModel(ApplicationSettings settings, INavigationService navigationService, IImageSearchService imageSearchService, IHub hub, IAccelerometer accelerometer, IStatusService statusService, IShareDataRequestedPump shareMessagePump)
        {
            _settings = settings;
            _navigationService = navigationService;
            _imageSearchService = imageSearchService;
            _hub = hub;
            _accelerometer = accelerometer;
            _statusService = statusService;

            HomeCommand = _navigationService.GoBackCommand;
            ViewDetailsCommand = new DelegateCommand(ViewDetails, () => SelectedImage != null);
            LoadMoreCommand = new AsyncDelegateCommand(LoadMore);
            ThumbnailViewCommand = new DelegateCommand(ThumbnailView);
            ListViewCommand = new DelegateCommand(ListView);
            SplitViewCommand = new DelegateCommand(SplitView);
            SettingsCommand = new DelegateCommand(Settings);

            AddImages(_settings.SelectedInstance.Images);
            shareMessagePump.DataToShare = _settings.SelectedInstance.QueryLink;
            _statusService.Title = _settings.SelectedInstance.Query;
            _accelerometer.Shaken += accelerometer_Shaken;
            _navigationService.Navigating += NavigatingFrom;

            UpdateCurrentView(CurrentView);
            _hub.Send(new UpdateTileImageCollectionMessage(_settings.SelectedInstance));
        }

 public HubInvokerContext(IHub hub, TrackingDictionary state, MethodDescriptor methodDescriptor, object[] args)
 {
     Hub = hub;
     MethodDescriptor = methodDescriptor;
     Args = args;
     State = state;
 }

        public void ProcessTurn(IHub services)
        {
            var personService = services.Resolve<IPersonService>();

            var gameClockService = services.Resolve<IGameClockService>();

            foreach(var person in personService.People.Where(p => !personService.IsRetired(p)))
            {
                if (person.RetirementDate > gameClockService.CurrentDate)
                {
                    continue;
                }

                var currentWorkHistory = person.WorkHistory.FirstOrDefault(wh => !wh.EndDate.HasValue);

                if(currentWorkHistory != null)
                {
                    var employee = currentWorkHistory.Company.GetEmployee(person.Id);

                    if(!employee.IsFounder)
                    {
                        currentWorkHistory.EndDate = gameClockService.CurrentDate;

                        currentWorkHistory.EndingSalary = employee.Salary;
                    }
                }
            }
        }

 internal static void UserInputLoop(IHub hub)
 {
     string userInput;
     while (!string.IsNullOrEmpty((userInput = Console.ReadLine())))
     {
         if (userInput.Equals("pose", StringComparison.OrdinalIgnoreCase))
         {
             foreach (var myo in hub.Myos)
             {
                 Console.WriteLine("Myo {0} in pose {1}.", myo.Handle, myo.Pose);
             }
         }
         else if (userInput.Equals("arm", StringComparison.OrdinalIgnoreCase))
         {
             foreach (var myo in hub.Myos)
             {
                 Console.WriteLine("Myo {0} is on {1} arm.", myo.Handle, myo.Arm.ToString().ToLower());
             }
         }
         else if (userInput.Equals("count", StringComparison.OrdinalIgnoreCase))
         {
             Console.WriteLine("There are {0} Myo(s) connected.", hub.Myos.Count);
         }
     }
 }

 public HubInvokerContext(IHub hub, StateChangeTracker tracker, MethodDescriptor methodDescriptor, IList<object> args)
 {
     Hub = hub;
     MethodDescriptor = methodDescriptor;
     Args = args;
     StateTracker = tracker;
 }

 public VoipChannel(IHub hub, CoreDispatcher dispatcher,
                    VoipContext context)
 {
     _hub = hub;
     Dispatcher = dispatcher;
     Context = context;
 }

        protected JiraServiceViewModel(IHub messageHub)
        {
            MessageHub = messageHub;

            SettingsCommand = new DelegateCommand(OpenSettings);
            SearchCommand = new DelegateCommand(ShowSearchPane);
        }

        public void ProcessTurn(IHub services)
        {
            var companyService = services.Resolve<ICompanyService>();

            var gameClockService = services.Resolve<IGameClockService>();

            foreach(var company in companyService.Companies)
            {
                foreach(var project in company.Projects)
                {
                    if (IsProjectComplete(project))
                    {
                        CompleteProject(company, project);

                        companyService.ProcessTransaction(company, TransactionType.Project, project.Value, $"Completed {project.Definition.Name} project.");

                    }
                    else
                    {
                        var deadline = project.ExtensionDeadline.HasValue ?
                                       project.ExtensionDeadline.Value :
                                       project.Deadline;

                        if (gameClockService.CurrentDate >= deadline)
                        {
                            FailProject(company, project);
                        }
                    }
                }
            }
        }

        protected override bool OnBeforeReconnect(IHub hub)
        {
            SignalRContext.ConnectionIdToSessionId[hub.Context.ConnectionId] = hub.GetSessionId();

            Storage session = hub.GetSession();
            session[InternalSessionKeys.DisconnectTimeKey] = null;
            return base.OnBeforeReconnect(hub);
        }

 protected override bool OnBeforeDisconnect(IHub hub, bool stopCalled)
 {
     if (stopCalled)
     {
         hub.ClearSession();
     }
     return base.OnBeforeDisconnect(hub, stopCalled);
 }

        public IssueViewModel(IHub messageHub, ISettings settings, IDialogService dialogService, IJiraService service)
            : base(messageHub)
        {
            _dialogService = dialogService;
            _settings = (ApplicationSettings)settings;
            _service = service;

            LoadIssueComments();
        }

        protected ServiceCore(IHub services)
        {
            if (services == null)
            {
                throw new ArgumentNullException(nameof(services));
            }

            _services = services;
        }

        protected override void OnAfterDisconnect(IHub hub, bool stopCalled)
        {
            string sessionId;
            SignalRContext.ConnectionIdToSessionId.TryRemove(hub.Context.ConnectionId, out sessionId);

            Storage session = hub.GetSession();
            session[InternalSessionKeys.DisconnectTimeKey] = DateTime.Now;
            base.OnAfterDisconnect(hub, stopCalled);
        }

        public void ProcessTurn(IHub services)
        {
            var companyService = services.Resolve<ICompanyService>();

            foreach(var company in companyService.Companies)
            {
                var accumulations = new Dictionary<int, decimal>();

                foreach (var employee in company.Employees)
                {
                    var allocations = company.Allocations.Where(a => a.Employee == employee);

                    var skillValues = new Dictionary<int, decimal>();

                    var remainingSkillValues = new Dictionary<int, decimal>();

                    foreach (var skill in employee.Person.Skills)
                    {
                        var skillValue = CalculateEmployeeSkillValue(employee, skill);

                        skillValues.Add(skill.SkillDefinition.Id, skillValue);

                        remainingSkillValues.Add(skill.SkillDefinition.Id, skillValue);
                    }

                    foreach (var allocation in allocations)
                    {
                        foreach (var requirement in allocation.Project.Requirements)
                        {
                            if (skillValues.ContainsKey(requirement.SkillDefinition.Id))
                            {
                                var value = allocation.Percent * skillValues[requirement.SkillDefinition.Id];

                                requirement.CurrentValue += value;

                                remainingSkillValues[requirement.SkillDefinition.Id] -= value;
                            }
                        }
                    }

                    foreach (var skill in remainingSkillValues)
                    {
                        if (accumulations.ContainsKey(skill.Key))
                        {
                            accumulations[skill.Key] += skill.Value;
                        }
                        else
                        {
                            accumulations.Add(skill.Key, skill.Value);
                        }
                    }
                }

                ProcessActionAccumulations(company, accumulations);
            }
        }

 private static void UpdateMeetingStatusToClients(IHub hub)
 {
     var meetingStati = BuildMeetingsStatus();
     
     Debug.WriteLine("Meeting Status Update:");
     foreach (var m in meetingStati)
     {
         Debug.WriteLine("Meeting {0} [HAsAgent:{1}] [HasClient:{2}] [MeetingStarted:{3}]", m.MeetingId, m.AgentJoined, m.ClientJoined, m.MeetingStarted);
     }
     hub.Clients.All.meetingStatusUpdated(meetingStati);
 }

        public override ActionExecutionInformation CanPerformEvent(Company company, IActionData eventData, IHub services)
        {
            var companyService = services.Resolve<ICompanyService>();

            if (!companyService.CanPerformAction(company, Type))
            {
                return new ActionExecutionInformation(false, $"Company {company.Id} cannot perform turn action {Type}.", company);
            }

            return new ActionExecutionInformation(true);
        }

        public ShellViewModel(AppName appName, ApplicationSettings settings, INavigationService navigationService, IHub hub)
        {
            _appName = appName;
            _settings = settings;
            _navigationService = navigationService;
            _hub = hub;

            Message = "Initializing...";
            IsLoading = true;

            BackCommand = _navigationService.GoBackCommand;
        }

        public IssuesViewModel(IJiraService jiraService, IHub messageHub, ApplicationSettings settings, INavigationService navigationService)
            : base(messageHub)
        {
            NavigateToIssueCommand = new DelegateCommand(NavigateToIssue, () => SelectedIssue != null);
            SettingsCommand = new DelegateCommand(OpenSettings);

            _applicationSettings = settings;
            _navigationService = navigationService;
            _jiraService = jiraService;

            _applicationSettings.SelectedIssue = null;
        }

        public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount)
        {
            var personService = services.Resolve<IPersonService>();

            var expectedCompensation = personService.CalculateCompensationValue(person);

            if(amount >= expectedCompensation)
            {
                return null;
            }

            return OfferResponseReason.OfferValue;
        }

        public CredentialsViewModel(IHub messageHub, ApplicationSettings settings)
        {
            IsSaveEnabled = true;

            _settings = settings;
            _messageHub = messageHub;

            _serverUrl = settings.ServerUrl;
            _userName = settings.UserName;
            _password = settings.Password;

            SaveCredentialsCommand = new AsyncDelegateCommand(SaveCredentials);
        }