public RexLoginResponse(UserAccount account, AgentCircuitData aCircuit, GridUserInfo pinfo,
     GridRegion destination, List<InventoryFolderBase> invSkel, FriendInfo[] friendsList, ILibraryService libService,
     string where, string startlocation, Vector3 position, Vector3 lookAt, List<InventoryItemBase> gestures, string message,
     GridRegion home, IPEndPoint clientIP, string mapTileURL, string searchURL)
     : base(account, aCircuit, pinfo, destination, invSkel, friendsList, libService, where, startlocation,
     position, lookAt, gestures, message, home, clientIP, mapTileURL, searchURL)
 {
 }

 public virtual void Start(IConfigSource config, IRegistryCore registry)
 {
     m_Database = Aurora.DataManager.DataManager.RequestPlugin<IInventoryData> ();
     m_UserAccountService = registry.RequestModuleInterface<IUserAccountService>();
     m_LibraryService = registry.RequestModuleInterface<ILibraryService>();
     m_AssetService = registry.RequestModuleInterface<IAssetService>();
 }

        public ArtistPageViewModel(
            INavigationService navigationService,
            ILibraryService libraryService,
            IEnumerable<IMetadataProvider> metadataProviders,
            IConverter<WebAlbum, Album> webAlbumConverter,
            IConverter<WebArtist, Artist> webArtistConverter,
            IConverter<WebSong, Track> webSongConverter,
            ISettingsUtility settingsUtility)
        {
            _navigationService = navigationService;
            _libraryService = libraryService;
            _webAlbumConverter = webAlbumConverter;
            _metadataProviders = metadataProviders.FilterAndSort<IExtendedMetadataProvider>();

            _webArtistConverter = webArtistConverter;
            _webSongConverter = webSongConverter;
            _settingsUtility = settingsUtility;

            AlbumClickCommand = new DelegateCommand<ItemClickEventArgs>(AlbumClickExecute);
            WebAlbumClickCommand = new DelegateCommand<ItemClickEventArgs>(WebAlbumClickExecute);

            if (IsInDesignMode)
            {
                OnNavigatedTo("Childish Gambino", NavigationMode.New, new Dictionary<string, object>());
            }
        }

        public SongsPageViewModel(
            ILibraryCollectionService libraryCollectionService,
            ILibraryService libraryService,
            ISettingsUtility settingsUtility,
            IPlayerService playerService)
        {
            _libraryCollectionService = libraryCollectionService;
            _settingsUtility = settingsUtility;
            _playerService = playerService;
            LibraryService = libraryService;

            SortItems =
                Enum.GetValues(typeof (TrackSort))
                    .Cast<TrackSort>()
                    .Select(sort => new ListBoxItem { Content = sort.GetEnumText(), Tag = sort })
                    .ToList();
            SortChangedCommand = new DelegateCommand<ListBoxItem>(SortChangedExecute);
            ShuffleAllCommand = new DelegateCommand(ShuffleAllExecute);

            var defaultSort = _settingsUtility.Read(ApplicationSettingsConstants.SongSort,
                TrackSort.DateAdded,
                SettingsStrategy.Roam);
            DefaultSort = SortItems.IndexOf(SortItems.FirstOrDefault(p => (TrackSort)p.Tag == defaultSort));
            ChangeSort(defaultSort);
        }

 public SyncClientService(ILibraryService libraryService, IAudioFileCacheService audioFileCacheService, ISyncDeviceSpecifications deviceSpecifications)
 {
     _libraryService = libraryService;
     _audioFileCacheService = audioFileCacheService;
     _deviceSpecifications = deviceSpecifications;
     Initialize();
 }

 public LibrariesController(ILibraryService libraryService , IUsersService usersService , IBookService bookssService , ICategoryService categoriesService)
 {
     this.libraryService = libraryService;
     this.usersService = usersService;
     this.booksService = bookssService;
     this.categoriesService = categoriesService;
 }

 public RexLoginService(IConfigSource config, ISimulationService simService, ILibraryService libraryService)
     : base(config, simService, libraryService)
 {
     //TODO: Read configuration about m_UseOSInventory
     //TODO: Read configuration about rexavatar
     //TODO: Load rexavatar plugin
 }

        public void LoadLibrary(ILibraryService service, IConfigSource source, IRegistryCore registry)
        {
            m_service = service;

            IConfig assetConfig = source.Configs["DefaultXMLAssetLoader"];
            if (assetConfig == null){
                return;
            }
            string loaderArgs = assetConfig.GetString("AssetLoaderArgs",
                        String.Empty);
            bool assetLoaderEnabled = !assetConfig.GetBoolean("PreviouslyLoaded", false);

            if (!assetLoaderEnabled)
                return;

            registry.RegisterModuleInterface<DefaultAssetXMLLoader>(this);

            MainConsole.Instance.InfoFormat("[DefaultXMLAssetLoader]: Loading default asset set from {0}", loaderArgs);
            IAssetService assetService = registry.RequestModuleInterface<IAssetService>();
            ForEachDefaultXmlAsset(loaderArgs,
                    delegate(AssetBase a)
                    {
                        if (!assetLoaderEnabled && assetService.GetExists(a.IDString))
                            return;
                        assetService.Store(a);
                    });
        }

 public EditViewModel(ILibraryService libraryService, IEventAggregator eventAggregator)
 {
     this._eventAggregator = eventAggregator;
     var orderedEnumerable = libraryService.GetObjectsFromFile().Videos.OrderBy(v=>v.Category).ToList();
     this.Videos = new ObservableCollection<Video>(orderedEnumerable);
     this.SelectedVideo = this.Videos.FirstOrDefault();
 }

        public WebFetchInvDescServerConnector(IConfigSource config, IHttpServer server, string configName) :
                base(config, server, configName)
        {
            if (configName != String.Empty)
                m_ConfigName = configName;

            IConfig serverConfig = config.Configs[m_ConfigName];
            if (serverConfig == null)
                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));

            string invService = serverConfig.GetString("InventoryService", String.Empty);

            if (invService == String.Empty)
                throw new Exception("No InventoryService in config file");

            Object[] args = new Object[] { config };
            m_InventoryService =
                    ServerUtils.LoadPlugin<IInventoryService>(invService, args);

            if (m_InventoryService == null)
                throw new Exception(String.Format("Failed to load InventoryService from {0}; config is {1}", invService, m_ConfigName));

            string libService = serverConfig.GetString("LibraryService", String.Empty);
            m_LibraryService =
                    ServerUtils.LoadPlugin<ILibraryService>(libService, args);

            WebFetchInvDescHandler webFetchHandler = new WebFetchInvDescHandler(m_InventoryService, m_LibraryService);
            IRequestHandler reqHandler = new RestStreamHandler("POST", "/CAPS/WebFetchInvDesc/" /*+ UUID.Random()*/, webFetchHandler.FetchInventoryDescendentsRequest);
            server.AddStreamHandler(reqHandler);
        }

        public void LoadLibrary(ILibraryService service, IConfigSource source, IRegistryCore registry)
        {
            m_service = service;
            m_registry = registry;
            m_Database = Framework.Utilities.DataManager.RequestPlugin<IInventoryData>();

            IConfig libConfig = source.Configs["InventoryIARLoader"];
            const string pLibrariesLocation = "DefaultInventory/";
            AddDefaultAssetTypes();
            if (libConfig != null)
            {
                if (libConfig.GetBoolean("WipeLibrariesOnNextLoad", false))
                {
                    service.ClearDefaultInventory(); //Nuke it
                    libConfig.Set("WipeLibrariesOnNextLoad", false);
                    source.Save();
                }
                if (libConfig.GetBoolean("PreviouslyLoaded", false))
                    return; //If it is loaded, don't reload
                foreach (string iarFileName in Directory.GetFiles(pLibrariesLocation, "*.iar"))
                {
                    LoadLibraries(iarFileName);
                }
            }
        }

 public LibraryMatchingService(ILibraryService libraryService, IMatchEngineService matchEngineService,
     IInsightsService insightsService, IDownloadService downloadService)
 {
     _libraryService = libraryService;
     _matchEngineService = matchEngineService;
     _insightsService = insightsService;
     _downloadService = downloadService;
 }

        public virtual void Start(IConfigSource config, IRegistryCore registry)
        {
            m_Database = DataManager.RequestPlugin<IInventoryData>();
            m_UserAccountService = registry.RequestModuleInterface<IUserAccountService>();
            m_LibraryService = registry.RequestModuleInterface<ILibraryService>();
            m_AssetService = registry.RequestModuleInterface<IAssetService>();

            registry.RequestModuleInterface<ISimulationBase>().EventManager.RegisterEventHandler("DeleteUserInformation", DeleteUserInformation);
        }

        public void IncomingCapsRequest (UUID agentID, Framework.Services.GridRegion region, ISimulationBase simbase, ref OSDMap capURLs)
        {
            m_agentID = agentID;
            m_moneyModule = simbase.ApplicationRegistry.RequestModuleInterface<IMoneyModule> ();
            m_assetService = simbase.ApplicationRegistry.RequestModuleInterface<IAssetService> ();
            m_inventoryService = simbase.ApplicationRegistry.RequestModuleInterface<IInventoryService> ();
            m_libraryService = simbase.ApplicationRegistry.RequestModuleInterface<ILibraryService> ();
            m_inventoryData = Framework.Utilities.DataManager.RequestPlugin<IInventoryData> ();

            HttpServerHandle method;
            string uri;

            method = (path, request, httpRequest, httpResponse) => HandleFetchInventoryDescendents (request, m_agentID);
            uri = "/CAPS/FetchInventoryDescendents/" + UUID.Random () + "/";
            capURLs ["WebFetchInventoryDescendents"] = MainServer.Instance.ServerURI + uri;
            capURLs ["FetchInventoryDescendents"] = MainServer.Instance.ServerURI + uri;
            capURLs ["FetchInventoryDescendents2"] = MainServer.Instance.ServerURI + uri;
            m_uris.Add (uri);
            MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", uri, method));

            method = (path, request, httpRequest, httpResponse) => HandleFetchLibDescendents (request, m_agentID);
            uri = "/CAPS/FetchLibDescendents/" + UUID.Random () + "/";
            capURLs ["FetchLibDescendents"] = MainServer.Instance.ServerURI + uri;
            capURLs ["FetchLibDescendents2"] = MainServer.Instance.ServerURI + uri;
            m_uris.Add (uri);
            MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", uri, method));

            method = (path, request, httpRequest, httpResponse) => HandleFetchInventory (request, m_agentID);
            uri = "/CAPS/FetchInventory/" + UUID.Random () + "/";
            capURLs ["FetchInventory"] = MainServer.Instance.ServerURI + uri;
            capURLs ["FetchInventory2"] = MainServer.Instance.ServerURI + uri;
            m_uris.Add (uri);
            MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", uri, method));

            method = (path, request, httpRequest, httpResponse) => HandleFetchLib (request, m_agentID);
            uri = "/CAPS/FetchLib/" + UUID.Random () + "/";
            capURLs ["FetchLib"] = MainServer.Instance.ServerURI + uri;
            capURLs ["FetchLib2"] = MainServer.Instance.ServerURI + uri;
            m_uris.Add (uri);
            MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", uri, method));


            uri = "/CAPS/NewFileAgentInventory/" + UUID.Random () + "/";
            capURLs ["NewFileAgentInventory"] = MainServer.Instance.ServerURI + uri;
            m_uris.Add (uri);
            MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", uri, NewAgentInventoryRequest));

            uri = "/CAPS/NewFileAgentInventoryVariablePrice/" + UUID.Random () + "/";
            capURLs ["NewFileAgentInventoryVariablePrice"] = MainServer.Instance.ServerURI + uri;
            m_uris.Add (uri);
            MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", uri, NewAgentInventoryRequestVariablePrice));

            uri = "/CAPS/CreateInventoryCategory/" + UUID.Random () + "/";
            capURLs ["CreateInventoryCategory"] = MainServer.Instance.ServerURI + uri;
            m_uris.Add (uri);
            MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", uri, CreateInventoryCategory));
        }

        public void RegisterCaps(IRegionClientCapsService service)
        {
            m_service = service;
            m_assetService = service.Registry.RequestModuleInterface<IAssetService>();
            m_inventoryService = service.Registry.RequestModuleInterface<IInventoryService>();
            m_libraryService = service.Registry.RequestModuleInterface<ILibraryService>();

            RestBytesMethod method = delegate(string request, string path, string param,
                                                                OSHttpRequest httpRequest, OSHttpResponse httpResponse)
            {
                return HandleWebFetchInventoryDescendents(request, m_service.AgentID);
            };
            service.AddStreamHandler("WebFetchInventoryDescendents",
                new RestBytesStreamHandler("POST", service.CreateCAPS("WebFetchInventoryDescendents", ""),
                                                      method));

            method = delegate(string request, string path, string param,
                                                                OSHttpRequest httpRequest, OSHttpResponse httpResponse)
            {
                return HandleFetchLibDescendents(request, m_service.AgentID);
            };
            service.AddStreamHandler("FetchLibDescendents",
                new RestBytesStreamHandler("POST", service.CreateCAPS("FetchLibDescendents", ""),
                                                      method));

            method = delegate(string request, string path, string param,
                                                                OSHttpRequest httpRequest, OSHttpResponse httpResponse)
            {
                return HandleFetchInventory(request, m_service.AgentID);
            };
            service.AddStreamHandler("FetchInventory",
                new RestBytesStreamHandler("POST", service.CreateCAPS("FetchInventory", ""),
                                                      method));

            method = delegate(string request, string path, string param,
                                                                OSHttpRequest httpRequest, OSHttpResponse httpResponse)
            {
                return HandleFetchLib(request, m_service.AgentID);
            };
            service.AddStreamHandler("FetchLib",
                new RestBytesStreamHandler("POST", service.CreateCAPS("FetchLib", ""),
                                                      method));

            service.AddStreamHandler("NewFileAgentInventory",
                new RestStreamHandler("POST", service.CreateCAPS("NewFileAgentInventory", m_newInventory),
                                                      NewAgentInventoryRequest));

            /*method = delegate(string request, string path, string param,
                                                                OSHttpRequest httpRequest, OSHttpResponse httpResponse)
            {
                return HandleInventoryItemCreate(request, m_service.AgentID);
            };
            service.AddStreamHandler("InventoryItemCreate",
                new RestBytesStreamHandler("POST", service.CreateCAPS("InventoryItemCreate", ""),
                                                      method));*/
        }

        protected AbstractObjectBrowserLibraryManager(string languageName, Guid libraryGuid, __SymbolToolLanguage preferredLanguage, IServiceProvider serviceProvider)
            : base(libraryGuid, serviceProvider)
        {
            _languageName = languageName;
            _preferredLanguage = preferredLanguage;

            var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
            this.Workspace = componentModel.GetService<VisualStudioWorkspace>();
            this.LibraryService = this.Workspace.Services.GetLanguageServices(languageName).GetService<ILibraryService>();
            this.Workspace.WorkspaceChanged += OnWorkspaceChanged;
        }

 public HomePageViewModel(IHomePage homePage, IEventAggregator eventAggregator, ILibraryService libraryService)
     : base(homePage)
 {
     this._eventAggregator = eventAggregator;
     this._libraryService = libraryService;
     this.GoToSettingsCommand = new DelegateCommand(this.GoToSettings);
     this.GoToVideosCommand = new DelegateCommand(this.GoToVideos);
     this.CleanCommand = new DelegateCommand(this.Clean);
     this.LoadCommand = new DelegateCommand(this.LoadAsync);
     this.ManageCommand = new DelegateCommand(this.GoToManage);
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="Sessions.UI.UpdateLibraryService"/> class.
		/// </summary>
		public UpdateLibraryService(ILibraryService libraryService)
		{
			if(libraryService == null)
				throw new ArgumentNullException("The _libraryService parameter cannot be null!");

			_libraryService = libraryService;
			_workerUpdateLibrary = new BackgroundWorker();
            _workerUpdateLibrary.WorkerReportsProgress = true;
            _workerUpdateLibrary.WorkerSupportsCancellation = true;
            _workerUpdateLibrary.DoWork += new DoWorkEventHandler(workerUpdateLibrary_DoWork);
            _workerUpdateLibrary.RunWorkerCompleted += new RunWorkerCompletedEventHandler(workerUpdateLibrary_RunWorkerCompleted);
		}

 public DownloadService(
     ILibraryService libraryService,
     IDispatcherUtility dispatcherUtility,
     IAppSettingsUtility appSettingsUtility,
     IPlayerService playerService)
 {
     _libraryService = libraryService;
     _dispatcherUtility = dispatcherUtility;
     _appSettingsUtility = appSettingsUtility;
     _playerService = playerService;
     ActiveDownloads = new ObservableCollection<Track>();
 }

        public SettingsPageViewModel(
            IAppSettingsUtility appSettingsUtility,
            IMusicImportService musicImportService,
            ILibraryService libraryService)
        {
            _musicImportService = musicImportService;
            _libraryService = libraryService;
            AppSettingsUtility = appSettingsUtility;

            ImportCommand = new DelegateCommand(ImportExecute);
            DeleteCommand = new DelegateCommand(DeleteExecute);
        }