/// <summary>
 /// Create a new project
 /// </summary>
 public ProjectViewModel(IAppService appService)
 {
     this._AppService = appService;
     Project = new Model.TranslationProject();
     Groups = new ObservableCollection<GroupViewModel>();
     Editors = new ObservableCollection<TranslationEditorViewModel>();
     OpenTranslationCommand = new RelayCommand<TranslationFileViewModel>(
         async file => {
             Exception error = null;
             try
             {
                 await OpenTranslationAsync(file);
             }
             catch (Exception ex)
             {
                 error = ex;
             }
             if (error != null)
                 await _AppService.ShowError(error);
         },
         file => file != null
         );
     CloseEditorCommand = new RelayCommand<TranslationEditorViewModel>(
         async editor => await CloseEditorAsync(editor),
         editor => editor != null
         );
 }

 public AppInstaller(IAppService appService, ILog log, IAppLinksService appLinksService,  IRoutes routes)
 {
     _appService = appService;
     _logger = log;
     _appLinksService = appLinksService;
     _routes = routes;
 }

			EditMenuCommand(Lazy<IUndoCommandService> undoCommandService, Lazy<IAddUpdatedNodesHelperProvider> addUpdatedNodesHelperProvider, IAppService appService, IPickFilename pickFilename)
				: base(appService.DocumentTreeView) {
				this.undoCommandService = undoCommandService;
				this.addUpdatedNodesHelperProvider = addUpdatedNodesHelperProvider;
				this.appService = appService;
				this.pickFilename = pickFilename;
			}

			CodeCommand(Lazy<IUndoCommandService> undoCommandService, Lazy<IAddUpdatedNodesHelperProvider> addUpdatedNodesHelperProvider, IAppService appService, EditCodeVMCreator editCodeVMCreator)
				: base(appService.DocumentTreeView) {
				this.undoCommandService = undoCommandService;
				this.addUpdatedNodesHelperProvider = addUpdatedNodesHelperProvider;
				this.appService = appService;
				this.editCodeVMCreator = editCodeVMCreator;
			}

        public ActionResult Execute(IAppService app)
        {
            WebsiteDirectory = FileUtil.MapPath("/");
            FileSystem = app.CompositionService.Resolve<IFileSystemService>();
            Trace = app.CompositionService.Resolve<ITraceService>();
            Factory = app.CompositionService.Resolve<IFactoryService>();

            foreach (var pair in app.Configuration.GetSubKeys("import-website"))
            {
                var key = "import-website:" + pair.Key;

                var databaseName = app.Configuration.GetString(key + ":database");
                if (key == "import-website:exclude-fields")
                {
                    continue;
                }

                if (!string.IsNullOrEmpty(databaseName))
                {
                    ImportItems(app, key);
                }
                else
                {
                    ImportFiles(app, key);
                }
            }

            return null;
        }

        /// <summary>
        /// Initializes a new instance of the MainViewModel class.
        /// </summary>
        /// 
        /// 
        public MainViewModel(IUserDataRepository userDataRepository,IAppService appService)
        {
            _appService = appService;
            _appService.AuthenticateUser();

            _userDataRepository = userDataRepository;
        }

        public PlayerViewModel(IUserDataRepository userDataRepository, IAppService appService)
        {
            _userDataRepository = userDataRepository;
                _appService = appService;

                Messenger.Default.Register<Song>(this, PlayListChange);
        }

        public ActionResult Execute(IAppService app)
        {
            TempFolder.EnsureFolder();

            var tempDirectory = Path.Combine(FileUtil.MapPath(TempFolder.Folder), "Pathfinder.Exports");
            if (Directory.Exists(tempDirectory))
            {
                FileUtil.DeleteDirectory(tempDirectory, true);
            }

            Directory.CreateDirectory(tempDirectory);

            var exportFileName = Path.Combine(FileUtil.MapPath(tempDirectory), "Pathfinder.Exports.zip");
            using (var zip = new ZipWriter(exportFileName))
            {
                foreach (var index in app.Configuration.GetSubKeys("write-website-exports"))
                {
                    var entryName = app.Configuration.GetString("write-website-exports:" + index.Key + ":filename");
                    var fileKey = "write-website-exports:" + index.Key + ":";

                    var fileName = Path.Combine(tempDirectory, PathHelper.NormalizeFilePath(entryName).TrimStart('\\'));

                    Directory.CreateDirectory(Path.GetDirectoryName(fileName) ?? string.Empty);

                    WriteFile(app.Configuration, tempDirectory, fileName, fileKey);

                    zip.AddEntry(entryName, fileName);
                }
            }

            return new FilePathResult(exportFileName, "application/zip");
        }

        public ActionResult Execute(IAppService app)
        {
            TempFolder.EnsureFolder();

            var fileName = FileUtil.MapPath(TempFolder.GetFilename("Pathfinder.Resources.zip"));

            using (var zip = new ZipWriter(fileName))
            {
                foreach (var pair in app.Configuration.GetSubKeys("sync-website:files"))
                {
                    var configKey = "sync-website:files:" + pair.Key + ":";
                    var syncFileName = app.Configuration.GetString(configKey + "file");

                    foreach (var synchronizer in Synchronizers)
                    {
                        if (synchronizer.CanSynchronize(app.Configuration, syncFileName))
                        {
                            synchronizer.Synchronize(app.Configuration, zip, syncFileName, configKey);
                        }
                    }
                }
            }

            return new FilePathResult(fileName, "application/zip");
        }

        public ActionResult Execute(IAppService app)
        {
            SerializingDataProvider.Disabled = true;
            try
            {
                foreach (var mapper in PathMapper.WebsiteItemPathToProjectDirectories)
                {
                    DeleteItems(mapper);
                }

                foreach (var mapper in PathMapper.WebsiteDirectoryToProjectDirectories)
                {
                    DeleteFiles(app.ProjectDirectory, mapper);
                }

                var fileSystem = app.CompositionService.Resolve<IFileSystemService>();

                foreach (var pair in app.Configuration.GetSubKeys("reset-website"))
                {
                    var key = "reset-website:" + pair.Key;

                    ResetItems(app, key);
                    ResetFiles(app, fileSystem, key);
                }
            }
            finally
            {
                SerializingDataProvider.Disabled = false;
            }

            return null;
        }

        public FriendListViewModel(IUserDataRepository userDataRepository, IAppService appService)
        {
            _userDataRepository = userDataRepository;
                _appService = appService;

                SelectionChanged = new RelayCommand(Go);
        }

        public override void Troubleshoot(IAppService app)
        {
            Console.WriteLine(Texts.Rebuilding_indexes___);

            BackgroundJob.Run("Pathfinder Rebuild ContentSearch Indexes", "Indexing", RebuildContentSearchIndexes);
            BackgroundJob.Run("Pathfinder Rebuild Classic Indexes", "Indexing", () => RebuildClassicIndex("master"));
            BackgroundJob.Run("Pathfinder Rebuild Classic Indexes", "Indexing", () => RebuildClassicIndex("core"));
        }

 public AppController(
     IUserService userService, 
     IFormsAuthenticationService formsAuthenticationService, 
     IAppService appService)
     : base(userService, formsAuthenticationService)
 {
     _appService = appService;
 }

        public PlayListViewModel(IUserDataRepository userDataRepository, IAppService appService)
        {
            _userDataRepository = userDataRepository;
            _appService = appService;

            SelectionChanged = new RelayCommand(Go);
            Messenger.Default.Register<PlayList>(this,PlayListChange);
        }

 public AuthorizationServerProvider(IUserService userService, IAdminUserService adminUserService,
     IAppService appService, ICommandBus commandBus)
 {
     this.userService = userService;
     this.adminUserService = adminUserService;
     this.appService = appService;
     this.commandBus = commandBus;
 }

 public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager, IDragonUserStore<AppMember> userStore, IFederationService federationService, IAppService appService)
 {
     _userStore = userStore;
     _federationService = federationService;
     _appService = appService;
     UserManager = userManager;
     SignInManager = signInManager;
 }

 public UserController(IUserProfileService userProfileService, IUserFancyAppService userFancyAppService
         , IAppService appService, IRoleService roleService, IRoleAppService roleAppService
     )
 {
     this._userProfileService = userProfileService;
     this._userFancyAppService = userFancyAppService;
     this._appService = appService;
     this._roleService = roleService;
     this._roleAppService = roleAppService;
 }

 public UserController(
     IUserService userService,
     IWordService wordService,
     IFormsAuthenticationService formsAuthenticationService,
     IAppService appService)
     : base(userService, formsAuthenticationService)
 {
     _appService = appService;
     _wordService = wordService;
 }

        public ActionResult Execute(IAppService app)
        {
            Context.SetActiveSite("shell");

            foreach (var troubleshooter in Troubleshooters.OrderBy(t => t.Priority))
            {
                troubleshooter.Troubleshoot(app);
            }

            return null;
        }

        public AuthorizeBackend()
        {
            AppService = DependencyResolver.Current.GetService(typeof(IAppService)) as IAppService;

            var roles = new List<RolesEnum>
                            {
                                RolesEnum.Backend,
                                RolesEnum.Supporter
                            };

            Roles = string.Join(",", roles);
        }