public MeApiController(UserManager<ApplicationUser> userManager,
     SignInManager<ApplicationUser> signInManager,
     IMediator mediator)
 {
     _userManager = userManager;
     _signInManager = signInManager;
     _mediator = mediator;
 }

        public CommandConsole(IMediator mediator, Log<string> commandLog)
        {
            _mediator = mediator;

            Active = false;
            Log = commandLog;
        }

 public override async Task SetTarget(IConfiguration moduleConfiguration, IMediator mediator)
 {
     var config = moduleConfiguration as DelcomConfiguration;
     viewModel = new DelcomProfileManagerViewModel(config, mediator);
     await viewModel.Initialize();
     DataContext = viewModel;
 }

        public BuildModule(IMediator mediator)
            : base("/api")
        {
            this.Get["/builds/{teamProject?}/{buildDefinition?}/{buildNumber?}"] = parameters =>
            {
                var query = this.Bind<BuildsQuery>();

                var result = mediator.Send(query);

                return this.Response.AsJson(result);
            };

            this.Get["/builds/stats"] = parameters =>
            {
                var query = this.Bind<BuildStatsQuery>();

                var result = mediator.Send(query);

                return this.Response.AsJson(result);
            };

            this.Get["/builds/perDay"] = parameters =>
            {
                var query = this.Bind<BuildsPerDayQuery>();

                var response = mediator.Send(query);

                return this.Response.AsJson(response);
            };
        }

 public UploadCollection(IDialogManager dialogManager, IMediator mediator,
     Func<CollectionCreatedViewModel> collectionCreatedFactory, ISpecialDialogManager specialDialogManager) {
     _dialogManager = dialogManager;
     _mediator = mediator;
     _collectionCreatedFactory = collectionCreatedFactory;
     _specialDialogManager = specialDialogManager;
 }

 public ActivityController(IAllReadyDataAccess dataAccess, UserManager<ApplicationUser> userManager, IImageService imageService, IMediator bus)
 {
     _dataAccess = dataAccess;
     _userManager = userManager;
     _imageService = imageService;
     _bus = bus;
 }

        public PickCollectionViewModel(IMediator mediator) {
            _mediator = mediator;
            Items = new ReactiveList<PickCollectionDataModel>();
            UiHelper.TryOnUiThread(() => {
                Items.EnableCollectionSynchronization(_itemsLock);
                ItemsView =
                    Items.CreateCollectionView(new List<SortDescription> {
                        new SortDescription("Name", ListSortDirection.Ascending)
                    }, null, new List<string> {"Name"}, OnFilter, true);
            });
            SelectedItems = new ReactiveList<PickCollectionDataModel>();

            this.WhenAnyValue(x => x.FilterText)
                .Throttle(Common.AppCommon.DefaultFilterDelay)
                .ObserveOn(RxApp.MainThreadScheduler)
                .Subscribe(x => ItemsView.TryRefreshIfHasView());

            this.SetCommand(x => x.OkCommand,
                this.WhenAnyValue(x => x.SelectedItems.Count).Select(x => x > 0), false)
                .RegisterAsyncTask(Process)
                .Subscribe();

            OkCommand.IsExecuting.Subscribe(x => IsExecuting = x);

            DisplayName = "Add mod to Collections";
        }

        public FacilityControllerTests()
        {
            mediator = A.Fake<IMediator>();

            A.CallTo(() => mediator.SendAsync(A<GetCountries>._)).Returns(new List<CountryData>
            {
                new CountryData
                {
                    Id = new Guid("4345FB05-F7DF-4E16-939C-C09FCA5C7D7B"),
                    Name = "United Kingdom"
                },
                new CountryData
                {
                    Id = new Guid("29B0D09E-BA77-49FB-AF95-4171408C07C9"),
                    Name = "Germany"
                }
            });

            A.CallTo(
                () =>
                    mediator.SendAsync(A<GetNotificationBasicInfo>.That.Matches(p => p.NotificationId == notificationId)))
                .Returns(new NotificationBasicInfo
                {
                    CompetentAuthority = UKCompetentAuthority.England,
                    NotificationId = notificationId,
                    NotificationNumber = "GB 0001 002000",
                    NotificationType = NotificationType.Recovery
                });

            facilityController = new FacilityController(mediator, new AddAddressBookEntryMap());
        }

        public void Setup()
        {
            DependencyConfig.RegisterDependencies();
            _mediator = DependencyConfig.Container.GetInstance<IMediator>();

            Database.MigrateToLastVersion();
        }

 public RiggedDeal(IList<PlayerBase> players, PassingMode mode,
     IMediator mediator,
     Dictionary<PlayerBase, IList<Card>> map)
     : base(players, 100, mode, mediator)
 {
     _map = map;
 }

        public DownloadViewModel(IMessageBox messageBox, IMediator mediator, SettingsManager settingsManager)
        {
            _messageBox = messageBox;
            _mediator = mediator;
            _settingsManager = settingsManager;

            _mediator.Register(this);

            UIEnabled = true;

            SelectedQuality = QualityList.FirstOrDefault(q => q.Id == _settingsManager.Settings.MaxQuality) ?? QualityList[0];
            TargetPath = _settingsManager.Settings.TargetPath;

            AddCommand = new DelegateCommand(ExecuteAddCommand);
            TargetCommand = new DelegateCommand(ExecuteTargetCommand);
            GoCommand = new DelegateCommand(ExecuteGoCommand);
            StopCommand = new DelegateCommand(ExecuteStopCommand);

            ImportCommand = new DelegateCommand(ExecuteImportCommand);

            Queue = new VideoQueue();
            Queue.TotalProgressChanged += TotalProgressChanged;
            Queue.QueueStateChanged += QueueStateChanged;
            Queue.VideoFinished += VideoFinished;

            FinishedVideos = new ObservableCollection<Video>();
        }

        public BuildDefinitionModule(IMediator mediator, IDocumentSession session)
            : base("/api")
        {
            this.Get["/build-definitions/{teamProject?}"] = parameters =>
            {
                var query = this.Bind<GetBuildDefinitions>();

                var results = mediator.Send(query);

                return this.Response.AsJson(results);
            };

            this.Get["/build-definitions/stats/{teamProject?}"] = parameters =>
            {
                var query = this.Bind<GetBuildDefinitionsStats>();

                var results = mediator.Send(query);

                return this.Response.AsJson(results);

                //string teamProject = parameters.TeamProject;

                //var query = session.Query<BuildDefinitionStats, BuildDefinitionStatusIndex>()
                //    .AsQueryable();

                //if (!string.IsNullOrEmpty(teamProject))
                //{
                //    query = query.Where(k => k.TeamProject == teamProject);
                //}

                //var results = query.ToList();

                //return this.Response.AsJson(results);
            };
        }

		public DisplayLabel(IMediator mediator) {
			this.Content = "Starting ...";
			this.FontSize = 24;
			//this.FontWeight = new FontWeight();
			this._mediator = mediator;
			this._mediator.RegisterDisplay(this);
		}

        public TaskController(IMediator mediator)
        {
            if (mediator == null)
                throw new ArgumentNullException("mediator");

            _mediator = mediator;
        }

        public Request ToModel(RequestViewModel requestViewModel, IMediator mediator)
        {
            var request = new Request
            {
                ProviderId = requestViewModel.ProviderId,
                ProviderData = requestViewModel.ProviderData,
                Address = requestViewModel.Address,
                City = requestViewModel.City,
                DateAdded = DateTime.UtcNow,
                Email = requestViewModel.Email,
                Name = requestViewModel.Name,
                Phone = requestViewModel.Phone,
                State = requestViewModel.State,
                Zip = requestViewModel.Zip,
                Status = RequestStatus.Unassigned,
                Latitude = requestViewModel.Latitude,
                Longitude = requestViewModel.Longitude
            };

            RequestStatus status;
            if (Enum.TryParse(requestViewModel.Status, out status))
            {
                request.Status = status;
            }

            return request;
        }

        public TodoItemsModule(IMediator mediator) : base("/todo-items")
        {
            _mediator = mediator;
            Get["/"] = parameters =>
            {
                var todoItems = _mediator.Send(new GetTodoItems());

                return Response.AsJson(todoItems);
            };

            Get["/{id}"] = parameters =>
            {
                var todoItem = _mediator.Send(new GetTodoItemById(parameters.id));

                return Response.AsJson(todoItem);
            };

            Post["/"] = parameters =>
            {
                var createTodoItem = this.Bind<CreateTodoItem>();
                var item =_mediator.Send(createTodoItem);
                return item;
            };

            Put["/{id}/complete"] = parameters =>
            {
                var id = parameters.id;
                var todoItem = _mediator.Send(new MarkTodoItemCompleted(id));
                return todoItem;
            };
        }

        public static async Task BindCountryList(this Controller controller, IMediator mediator,
            bool setDefaultAsUnitedKingdom = true)
        {
            var response = await mediator.SendAsync(new GetCountries());

            BindCountriesToViewBag(controller, response, setDefaultAsUnitedKingdom);
        }

		public UsersController(CollectionsReadModel collectionsReadModel, AuthorizationReadModel authReadModel, JsonSerializerSettings settings, IMediator mediator)
		{
			_collectionsReadModel = collectionsReadModel;
			_authReadModel = authReadModel;
			_settings = settings;
			_mediator = mediator;
		}

 public RealVirtualityLauncher(IMediator mediator, IGameLauncherProcess processManager,
     IPathConfiguration pathConfiguration, IFileWriter writer)
     : base(mediator, processManager) {
     Contract.Requires<ArgumentNullException>(writer != null);
     _writer = writer;
     _parPath = pathConfiguration.LocalDataPath.GetChildDirectoryWithName("games");
 }

 public UserController(IUserService userService, IFormsAuthenticationService formsAuthenticationService,
     TardisConfiguration configuration, IMediator mediator)
 {
     this.userService = userService;
     this.formsAuthenticationService = formsAuthenticationService;
     this.configuration = configuration;
     this.mediator = mediator;
 }