protected void Page_Load(object sender, EventArgs e)
    {
        // get id from query string
        int id = Convert.ToInt32(Request.QueryString["id"]);
        string type = Request.QueryString["type"];

        if (type == "doc")
        {
            // get document for id
            FileManager fm = new FileManager();
            Document d = fm.documentForID(id);
            Response.Write(Request.QueryString["id"]);

            Response.Clear();
            Response.Buffer = true;

            Response.ContentType = d.MIMEType;
            Response.BinaryWrite(d.fileContent);
        }
        else {
            ReportManager rm = new ReportManager();
           Report r = rm.ReportForID(id);
            Response.Write(Request.QueryString["id"]);

            Response.Clear();
            Response.Buffer = true;

            Response.ContentType = r.MIMEType;
            Response.BinaryWrite(r.FileContent);
        }
        Response.Flush();
        Response.End();
    }

        public void Setup()
        {
            _mockData = MockComponentProvider.CreateDataProvider();
            _mockFolder = MockComponentProvider.CreateFolderProvider(Constants.FOLDER_ValidFolderProviderType);
            _mockCache = MockComponentProvider.CreateDataCacheProvider();

            _folderManager = new Mock<IFolderManager>();
            _folderPermissionController = new Mock<IFolderPermissionController>();
            _portalController = new Mock<IPortalController>();
            _folderMappingController = new Mock<IFolderMappingController>();
            _globals = new Mock<IGlobals>();
            _cbo = new Mock<ICBO>();
            _pathUtils = new Mock<IPathUtils>();

            _fileManager = new FileManager();

            FolderManager.RegisterInstance(_folderManager.Object);
            FolderPermissionControllerWrapper.RegisterInstance(_folderPermissionController.Object);
            PortalControllerWrapper.RegisterInstance(_portalController.Object);
            FolderMappingController.RegisterInstance(_folderMappingController.Object);
            TestableGlobals.SetTestableInstance(_globals.Object);
            CBOWrapper.RegisterInstance(_cbo.Object);
            PathUtils.RegisterInstance(_pathUtils.Object);

            _mockFileManager = new Mock<FileManager> { CallBase = true };

            _folderInfo = new Mock<IFolderInfo>();
            _fileInfo = new Mock<IFileInfo>();
        }

        /// <summary>
        /// This only needs to be called from ComponentManager
        /// </summary>
        public override void Initialize() {
            SetDebugConditional();

            RunningOn = CurrentLocation;

            Files = new FileManager(); 
            Files.Initialize();  // logging depends on this

            Log.Info("Starting SE Garden v" + ModInfo.Version, "");

            Commands = new ChatManager();
            Commands.Initialize();

            Messages = new MessageManager();
            Messages.Initialize();

            if (ModInfo.DebugMode) {
                Specification.RunSpecTests(
                    "SEGarden",
                    new List<Specification>() {
                        new ItemCountAggregateDefinitionSpec(),
                        new ItemCountDefinitionSpec()
                    }
                );
            }

            base.Initialize();
        }

        public MainPage()
        {
            InitializeComponent();

            this.fileManager = new FileManager(this.diagram);
            this.toolBox.ItemsSource = new HierarchicalGalleryItemsCollection();
        }

        public override void GenerateCode(FileManager fileManager, SymbolTable symbolTable, CodeGeneratorHelper codeGeneratorHelper)
        {
            AppendNodeComment(fileManager);

            // Initialization assignment
            this._children[0].GenerateCode(fileManager, symbolTable, codeGeneratorHelper);

            // Generate loop start label
            string startLabel = codeGeneratorHelper.GenerateNextLabel();
            fileManager.Output.Append(Macro.Label(startLabel));

            // Check condition and jump out if false
            this._children[1].GenerateCode(fileManager, symbolTable, codeGeneratorHelper);
            string outLabel = codeGeneratorHelper.GenerateNextLabel();
            fileManager.Output.Append(Macro.JumpOnFalse(outLabel));

            // Loop body
            this._children[3].GenerateCode(fileManager, symbolTable, codeGeneratorHelper);

            // Altering assignment
            this._children[2].GenerateCode(fileManager, symbolTable, codeGeneratorHelper);

            // Jump back to condition check
            fileManager.Output.Append(Macro.Jump(startLabel));

            // Generate loop end label
            fileManager.Output.Append(Macro.Label(outLabel));
        }

        protected override void Initialize()
        {
            theFileManager = FileManager.Get(this);
            theInputManager = InputManager.Get(this);
            theUtilityManager = UtilityManager.Get(this);
            theTileManager = TileManager.Get(this);
            theButtonManager = ButtonManager.Get(this);
            thePlayerManager = PlayerManager.Get(this);
            theScreenManager = ScreenManager.Get(this);
            theCameraManager = CameraManager.Get(this);
            theEnemyManager = EnemyManager.Get(this);
            theProjectileManager = ProjectileManager.Get(this);
            theCollisionManager = CollisionManager.Get(this);

            theScreenManager.WorldScreen = new MainMenu();

            Player.CreatePlayer("test", new Vector2(mScreenDimensions.X / 2.0f, mScreenDimensions.Y / 2.0f), Vector2.Zero);

            TileButton.Create(new FloorCopper(), Keys.E);
            TileButton.Create(new FloorMetal(), Keys.R);
            TileButton.Create(new HardWallCopper(), Keys.T);
            TileButton.Create(new HardWallMetal(), Keys.Y);
            TileButton.Create(new WallMetal(), Keys.Q);
            TileButton.Create(new CopperWall(), Keys.W);

            EnemyButton.Create(new EnemyTurret(), Keys.F);
             //   EnemyButton.Create("Turret_Gun", Keys.F);

            theTileManager.Load("Level_1.xml");

            base.Initialize();
        }

        public IEnumerable<SearchResult> Search(SearchQuery query, FileManager fileManager)
        {
            var repos = from dir in fileManager.DirectoryInfo.EnumerateDirectories()
                        let repoInfo = GitUtilities.GetRepoInfo(dir.FullName)
                        where repoInfo.IsGitRepo
                        select repoInfo;

            foreach (var repo in repos)
            {
                if (query.Terms.All(t => repo.Name.IndexOf(t, StringComparison.OrdinalIgnoreCase) != -1 || repo.Description.IndexOf(t, StringComparison.OrdinalIgnoreCase) != -1))
                {
                    yield return new SearchResult
                    {
                        LinkText = repo.Name,
                        ActionName = "ViewRepo",
                        ControllerName = "Browse",
                        RouteValues = new { repo = repo.Name },
                        Lines = new List<SearchLine>
                        {
                            new SearchLine { Line = repo.Description },
                        },
                    };
                }
            }
        }

        public override void LoadContent(ContentManager Content, InputManager inputManager)
        {
            base.LoadContent(Content, inputManager);
            if (font== null)
                font = content.Load<SpriteFont>("Font1");

            imageNumber = 0;
            fileManager = new FileManager();
            fade = new List<FadeAnimation>();
            images = new List<Texture2D>();

            fileManager.LoadContent("Load/Splash.cme", attributes, contents);

            for (int i = 0; i < attributes.Count; i++)
            {
                for (int j = 0; j < attributes[i].Count; j++)
                {
                    switch (attributes[i][j])
                    {
                        case "Image":
                            images.Add(content.Load<Texture2D>(contents[i][j]));
                            fade.Add(new FadeAnimation());
                            break;
                    }
                }
            }
            for (int i = 0; i < fade.Count; i++)
            {
                fade[i].LoadContent(content, images[i], "", new Vector2(80,60));
                fade[i].Scale = 1.25f;
                fade[i].IsActive = true;
            }
        }

        public void GetTempFileNameReturnsNewFileName()
        {
            // Arrange.
            const string TempDocumentUNC = @"z:\Temp\";
            var guid1 = new Guid("{D98C2A44-FACF-4FD4-ACA8-EBBE3AD6A173}");
            var guid2 = new Guid("{28FAEA09-F87A-42F4-B7AA-18079670C428}");

            var fileManager = new FileManager();
            var systemOptions = Mock.Create<ISystemOptionsInfo>();
            Mock.Arrange(() => systemOptions.TempDocumentUNC).Returns(TempDocumentUNC);
            Mock.Arrange(() => SystemOptionsInfo.GetSystemOptionsInfo()).Returns(systemOptions);
            Mock.Arrange(() => Guid.NewGuid()).Returns(guid1).InSequence();
            Mock.Arrange(() => Guid.NewGuid()).Returns(guid2).InSequence();

            Mock.Arrange(() => Directory.Exists(TempDocumentUNC)).Returns(true);
            Mock.Arrange(() => File.Create(Arg.AnyString)).Returns(() => Mock.Create<FileStream>(Behavior.Loose));

            // Act.
            var tempFile = fileManager.GetTempFileName(null);
            var tempFileWithExtension = fileManager.GetTempFileName("tmp");

            // Assert.
            Assert.AreEqual(@"z:\Temp\D98C2A44-FACF-4FD4-ACA8-EBBE3AD6A173", tempFile);
            Assert.AreEqual(@"z:\Temp\28FAEA09-F87A-42F4-B7AA-18079670C428.tmp", tempFileWithExtension);
            Mock.Assert(() => File.Create(@"z:\Temp\D98C2A44-FACF-4FD4-ACA8-EBBE3AD6A173"), Occurs.Once());
            Mock.Assert(() => File.Create(@"z:\Temp\28FAEA09-F87A-42F4-B7AA-18079670C428.tmp"), Occurs.Once());

            // Expected exceptions.
            Mock.Arrange(() => SystemOptionsInfo.GetSystemOptionsInfo()).Returns(() => null);
            TestsHelper.VerifyThrow<SystemOptionsLoadException>(() => fileManager.GetTempFileName(null));

            Mock.Arrange(() => systemOptions.TempDocumentUNC).Returns(string.Empty);
            Mock.Arrange(() => SystemOptionsInfo.GetSystemOptionsInfo()).Returns(systemOptions);
            TestsHelper.VerifyThrow<InvalidSystemOptionsException>(() => fileManager.GetTempFileName(null));
        }

        public static ICommand CreateCommand(FileManager manager, string commandLine)
        {
            manager.Parser.Parse(commandLine);

            switch (manager.Parser.CommandType)
            {
                case CommandTypes.NOP:
                    return new NOPCommand(manager.Parser.Operands);
                case CommandTypes.MD:
                    return new MDCommand(manager, manager.Parser.Operands);
                case CommandTypes.CD:
                    return new CDCommand(manager, manager.Parser.Operands);
                case CommandTypes.RD:
                    return new RDCommand(manager, manager.Parser.Operands);
                case CommandTypes.DELTREE:
                    return new DELTREECommand(manager, manager.Parser.Operands);
                case CommandTypes.MF:
                    return new MFCommand(manager, manager.Parser.Operands);
                case CommandTypes.MHL:
                    return new MHLCommand(manager, manager.Parser.Operands);
                case CommandTypes.MDL:
                    return new MDLCommand(manager, manager.Parser.Operands);
                case CommandTypes.DEL:
                    return new DELCommand(manager, manager.Parser.Operands);
                case CommandTypes.COPY:
                    return new COPYCommand(manager, manager.Parser.Operands);
                case CommandTypes.MOVE:
                    return new MOVECommand(manager, manager.Parser.Operands);
                case CommandTypes.DIR:
                    return new DIRCommand(manager, manager.Parser.Operands);
                default:
                    throw new UnknownCommandException(commandLine);
            }
        }

        public override void GenerateCode(FileManager fileManager, SymbolTable symbolTable, CodeGeneratorHelper codeGeneratorHelper)
        {
            AppendNodeComment(fileManager);

            // Check condition
            this._children[0].GenerateCode(fileManager, symbolTable, codeGeneratorHelper);

            // If the condition is false, jump to the else-statement (exit label if else-statement is null)
            string elseLabel = codeGeneratorHelper.GenerateNextLabel();
            fileManager.Output.Append(Macro.JumpOnFalse(elseLabel));

            // Then-statement
            this._children[1].GenerateCode(fileManager, symbolTable, codeGeneratorHelper);

            // On existing else-statement jump over it
            string outLabel = null;
            if (this._children[2] != null)
            {
                outLabel = codeGeneratorHelper.GenerateNextLabel();
                fileManager.Output.Append(Macro.Jump(outLabel));
            }

            // Generate else label
            fileManager.Output.Append(Macro.Label(elseLabel));

            // Else-statement and exit label
            if (this._children[2] != null)
            {
                this._children[2].GenerateCode(fileManager, symbolTable, codeGeneratorHelper);
                fileManager.Output.Append(Macro.Label(outLabel));
            }
        }

 public void Initialize()
 {
     SolutionConfigurationNode node = new SolutionConfigurationNode();
     ApplicationData applicationData = ApplicationData.FromCurrentAppDomain();
     appNode = new ApplicationConfigurationNode(applicationData.Name, applicationData);
     appNode.Load(null);
     fileManager = new FileManager(node);
 }

        public override void GenerateCode(FileManager fileManager, SymbolTable symbolTable, CodeGeneratorHelper codeGeneratorHelper)
        {
            AppendNodeComment(fileManager);

            this._children[0].GenerateCode(fileManager, symbolTable, codeGeneratorHelper);

            fileManager.Output.Append(Macro.MonadicOperator(this._opCodeSymbol));
        }

        //Contructor
        public MainMenu()
        {
            //Open center screen
            this.StartPosition = FormStartPosition.CenterScreen;
            InitializeComponent();

            fileManager = new FileManager();
        }

        public override void GenerateCode(FileManager fileManager, SymbolTable symbolTable, CodeGeneratorHelper labelHelper)
        {
            AppendNodeComment(fileManager);

            SyntaxTreeDeclarationNode declNode = symbolTable.GetDeclarationNodeLinkToSymbol(this.Identifier) as SyntaxTreeDeclarationNode;

            fileManager.Output.Append(Macro.LoadAccu(declNode.GetMemoryAddress()));
        }

 static EmpDocument()
 {
     _fileManager = new FileManager<MondaiDocument>("1.1", new FileAccessor<MondaiDocument>[]
     {
         new EmpDocumentAccessor1_1(),
         new EmpDocumentAccessor1_0(),
     }, new EmpFileVersionReader());
 }

 public static FileManager GetInst()
 {
     if(inst == null)
     {
         inst = new FileManager();
     }
     return inst;
 }

        public void GetResourceInfoTest_NoSpacesInUrl()
        {
            // Directory without spaces
            FileManager fm = new FileManager(_path);
            ResourceInfo info = fm.GetResourceInfo("mustard");

            Assert.AreEqual(ResourceType.Directory, info.Type);
        }

        public void GetResourceInfoTest_SpacesInUrl()
        {
            // Directory with spaces
            FileManager fm = new FileManager(_path);
            ResourceInfo info = fm.GetResourceInfo("yellow%20pepper");

            Assert.AreEqual(ResourceType.Directory, info.Type);
        }

        public Example()
        {
            InitializeComponent();

            this.Loaded += this.OnLoaded;
            this.fileManager = new FileManager(this.diagram);
            this.DataContext = new MainViewModel();
        }