public ManagedProjectReference(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, SolutionBase solution, TempFileCollection tfc, GacCache gacCache, DirectoryInfo outputDir)
            : base(referencesResolver, parent)
        {
            if (xmlDefinition == null) {
                throw new ArgumentNullException("xmlDefinition");
            }
            if (solution == null) {
                throw new ArgumentNullException("solution");
            }
            if (tfc == null) {
                throw new ArgumentNullException("tfc");
            }
            if (gacCache == null) {
                throw new ArgumentNullException("gacCache");
            }

            XmlAttribute privateAttribute = xmlDefinition.Attributes["Private"];
            if (privateAttribute != null) {
                _isPrivateSpecified = true;
                _isPrivate = bool.Parse(privateAttribute.Value);
            }

            // determine path of project file
            string projectFile = solution.GetProjectFileFromGuid(
                xmlDefinition.GetAttribute("Project"));

            // load referenced project
            _project = LoadProject(solution, tfc, gacCache, outputDir, projectFile);
        }

 public BattleDetailLogger()
 {
     Directory.CreateDirectory(@"logs\battlelog");
     Staff.API("api_req_map/start").Subscribe(x => AddApi("startnext", x));
     Staff.API("api_req_map/next").Subscribe(x => AddApi("startnext", x));
     Staff.API("api_req_sortie/battleresult").Subscribe(x => AddApi("battleresult", x));
     Staff.API("api_req_combined_battle/battleresult").Subscribe(x => AddApi("battleresult", x));
     Staff.API("api_req_sortie/battle").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_battle_midnight/battle").Subscribe(x => AddApi("nightbattle", x));
     Staff.API("api_req_battle_midnight/sp_midnight").Subscribe(x => AddApi("battle", x));
     //Staff.API("api_req_practice/battle").Subscribe(x => AddApi("battle", x));
     //Staff.API("api_req_practice/midnight_battle").Subscribe(x => AddApi("nightbattle", x));
     Staff.API("api_req_sortie/airbattle").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_sortie/ld_airbattle").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_combined_battle/airbattle").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_combined_battle/battle").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_combined_battle/midnight_battle").Subscribe(x => AddApi("nightbattle", x));
     Staff.API("api_req_combined_battle/sp_midnight").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_combined_battle/battle_water").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_combined_battle/ld_airbattle").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_combined_battle/ec_battle").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_combined_battle/ec_midnight_battle").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_combined_battle/each_battle").Subscribe(x => AddApi("battle", x));
     Staff.API("api_req_combined_battle/each_battle_water").Subscribe(x => AddApi("battle", x));
     var dir = new DirectoryInfo(@"logs\battlelog");
     foreach (var file in dir.GetFiles("*.log"))
     {
         date = DateTime.Parse(Path.GetFileNameWithoutExtension(file.Name));
         if (date != DateTime.UtcNow.Date)
             CompressFile();
     }
     date = DateTime.UtcNow.Date;
 }

		public void LoadPlugins(string pluginPath, bool checkSubDirs)
		{
			if(!Directory.Exists(pluginPath))
				return;
			if(Plugins.Any())
				UnloadPlugins();
			var dirInfo = new DirectoryInfo(pluginPath);

			var files = dirInfo.GetFiles().Select(f => f.FullName).ToList();
			if(checkSubDirs)
			{
				foreach(var dir in dirInfo.GetDirectories())
					files.AddRange(dir.GetFiles().Select(f => f.FullName));
			}

			foreach(var file in files)
			{
				var fileInfo = new FileInfo(file);

				if(fileInfo.Extension.Equals(".dll"))
				{
					var plugins = GetModule(file, typeof(IPlugin));
					foreach(var p in plugins)
						Plugins.Add(p);
				}
			}
			Logger.WriteLine("Loading Plugins...", "PluginManager");
			LoadPluginSettings();
		}

        /// <summary>
        /// Remove directories and files if selected
        /// </summary>
        private void BtDeleteClick(object sender, EventArgs e)
        {
            // Move CWD away as it prevents Windows OS to cleanly delete directory
            Directory.SetCurrentDirectory(App.AppHome);

            bool ret = true;
            // Depending on the selection, do the deletion:
            // 0: dont delete anythng
            // 1: delete only working files
            // 2: delete only .git tree
            // 3: delete complete repo folder

            if (_radioSelection == 1)
            {
                DirectoryInfo dirInfo = new DirectoryInfo(_dir);
                ret = ClassUtils.DeleteFolder(dirInfo, true, true);     // Preserve .git, preserve root folder
            }

            if (_radioSelection == 2)
            {
                DirectoryInfo dirInfo = new DirectoryInfo(_dir + Path.DirectorySeparatorChar + ".git");
                ret = ClassUtils.DeleteFolder(dirInfo, false, false);    // Remove .git, remove root folder (.git)
            }

            if(_radioSelection == 3)
            {
                DirectoryInfo dirInfo = new DirectoryInfo(_dir);
                ret = ClassUtils.DeleteFolder(dirInfo, false, false);   // Remove .git, remove root folder
            }

            if (ret == false)
                MessageBox.Show("Some files could not be removed!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
        }

        public DateTime? GetLatestUpdate()
        {
            if (_lastUpdated.HasValue) return _lastUpdated;

            var directory = new DirectoryInfo(BaseDirectory);

            var latest =
                directory.GetFiles("*.*", SearchOption.AllDirectories)
                    .OrderByDescending(f => f.LastWriteTimeUtc)
                    .FirstOrDefault();

            _lastUpdated = latest != null ? (DateTime?)latest.LastWriteTimeUtc : null;
            return _lastUpdated;
            /*
            var directory = new DirectoryInfo(BaseDirectory);

            if (!directory.Exists)
            {
                directory.Create();
                return null;
            }

            var latest =
    directory.GetFiles("*.*", SearchOption.AllDirectories)
        .OrderByDescending(f => f.LastWriteTimeUtc)
        .FirstOrDefault();

            return latest != null ? (DateTime?)latest.LastWriteTimeUtc : null;
             * */
        }

        public string GetBabylonScenes(string rootPath)
        {
            try
            {
                var dir = new DirectoryInfo(rootPath);
                var subDirs = dir.GetDirectories();
                var files = new List<JObject>();

                foreach (var directory in subDirs)
                {
                    var babylonFiles = directory.GetFiles("*.babylon");

                    if (babylonFiles.Length == 0)
                        continue;

                    foreach (var file in babylonFiles)
                    {
                        var linkName = directory.Name + "/" + Path.GetFileNameWithoutExtension(file.Name);
                        files.Add(new JObject(
                            new JProperty("url", Url.Action("Index", "BabylonJSDemo", new { demoFolderName = directory.Name, demoFile = file.Name })),
                            new JProperty("linkName", linkName)
                        ));
                    }
                }

                var json = new JObject(new JProperty("files", files));
                return json.ToString(Newtonsoft.Json.Formatting.None);
            }
            catch
            {
                var json = new JObject(new JProperty("files", ""));
                return json.ToString(Newtonsoft.Json.Formatting.None);
            }
        }

        public void LoadTemplateData()
        {
            #region 加载模板数据

            path = Utils.GetMapPath(@"..\..\templates\");

            string templatepath = "由于目录 : ";
            string templateidlist = "0";
            foreach (DataRow dr in buildGridData().Select("valid =1"))
            {
                DirectoryInfo dirinfo = new DirectoryInfo(path + dr["directory"].ToString() + "/");
                if (dr["directory"].ToString().ToLower() == "default")
                    continue;
                if (!dirinfo.Exists)
                {
                    templatepath += dr["directory"].ToString() + " ,";
                    templateidlist += "," + dr["templateid"].ToString();
                }
            }

            if ((templateidlist != "") && (templateidlist != "0"))
            {
                base.RegisterStartupScript("", "<script>alert('" + templatepath.Substring(0, templatepath.Length - 1) + "已被删除, 因此系统将自动更新模板列表!')</script>");
                AdminTemplates.DeleteTemplateItem(templateidlist);
                AdminVistLogs.InsertLog(this.userid, this.username, this.usergroupid, this.grouptitle, this.ip, "从数据库中删除模板文件", "ID为:" + templateidlist);
                Discuz.Cache.DNTCache.GetCacheService().RemoveObject("/Forum/TemplateIDList");
                Discuz.Forum.Templates.GetValidTemplateIDList();
            }

            DataGrid1.AllowCustomPaging = false;
            DataGrid1.DataSource = buildGridData();
            DataGrid1.DataBind();

            #endregion
        }

        private static bool ExtractZipArchive(string archive, string destination, FastZip fz)
        {

            DirectoryInfo newdirFI;

            if (!Directory.Exists(destination))
            {
                newdirFI = Directory.CreateDirectory(destination);

                if (!Directory.Exists(newdirFI.FullName))
                {
                    //MessageBox.Show("Directory " + destination + " could not be created.");
                    return false;
                }
            }
            else newdirFI = new DirectoryInfo(destination);


            try
            {
                Thread.Sleep(500);
                fz.ExtractZip(archive, newdirFI.FullName, "");
            }
            catch (Exception e)
            {
                Debugger.LogMessageToFile("The archive " + archive + " could not be extracted to destination " + destination +
                                          ". The following error ocurred: " + e);
            }



            return true;
        }

 private static void CreateDirectoryIfNotExists(DirectoryInfo directoryInfo)
 {
     if(!directoryInfo.Exists) {
         CreateDirectoryIfNotExists(directoryInfo.Parent);
         directoryInfo.Create();
     }
 }

        private IEnumerable<XElement> AddDirectoryAsync(DirectoryInfo dir, string collectionId, ref int count, int fnumber,
            BackgroundWorker worker)
        {
            List<XElement> addedElements = new List<XElement>();
            // добавление коллекции
            string subCollectionId;
            List<XElement> ae = this.cass.AddCollection(dir.Name, collectionId, out subCollectionId).ToList();
            if (ae.Count > 0) addedElements.AddRange(ae);

            count++;
            foreach (FileInfo f in dir.GetFiles())
            {
                if (worker.CancellationPending) break;
                if (f.Name != "Thumbs.db")
                    addedElements.AddRange(this.cass.AddFile(f, subCollectionId));
                count++;
                worker.ReportProgress(100 * count / fnumber);
            }
            foreach (DirectoryInfo d in dir.GetDirectories())
            {
                if (worker.CancellationPending) break;
                addedElements.AddRange(AddDirectoryAsync(d, subCollectionId, ref count, fnumber, worker));
            }
            return addedElements;
        }

        public static void NewlyCreatedFileDirectory()
        {
            DirectoryInfo directory = new DirectoryInfo("C:\\");
            FileInfo file = directory.GetFiles().OrderByDescending(f => f.LastWriteTime).First();
            Console.WriteLine("\n\nName:" + file.Name);
            Console.WriteLine("Full Name:" + file.FullName);
            Console.WriteLine("Read-Only:" + file.IsReadOnly);
            Console.WriteLine("Last Acces Time:" + file.LastAccessTime);
            Console.WriteLine("Last Write Time:" + file.LastWriteTime);
            Console.WriteLine("Length:" + file.Length);
            Console.WriteLine("Extension:" + file.Extension);
            Console.WriteLine("Attributes:" + file.Attributes);
            Console.WriteLine("Creation Time:" + file.CreationTime);
            Console.WriteLine("Directory Name: " + file.DirectoryName);

            DirectoryInfo directory1 = directory.GetDirectories().OrderByDescending(f => f.LastWriteTime).First();
            Console.WriteLine("\n\nDirectory Name:" + directory1.Name);
            Console.WriteLine("Parent:" + directory1.Parent);
            Console.WriteLine("Root:" + directory1.Root);
            Console.WriteLine("Last Write Time:" + directory1.LastWriteTime);
            Console.WriteLine("Last Access Time:" + directory1.LastAccessTime);
            Console.WriteLine("Extension:" + directory1.Extension);
            Console.WriteLine("Creation Time:" + directory1.CreationTime);
            Console.WriteLine("Attributes" + directory1.Attributes);
        }

        protected void btnUpload_Click(object sender, EventArgs e)
        {
            lb_notvalid.Visible = false;

            if (FileUpload1.HasFile)
            {
                Guid g = Guid.NewGuid();
                DirectoryInfo updir = new DirectoryInfo(Server.MapPath("/media/upload/" + g));

                if (!updir.Exists)
                    updir.Create();

                FileUpload1.SaveAs(updir.FullName + "/" + FileUpload1.FileName);

                if (IsValidImage(updir.FullName + "/" + FileUpload1.FileName))
                {

                    tb_url.Text = "/media/upload/" + g + "/" +
                        ResizeImage(updir.FullName + "/", FileUpload1.FileName,
                        500, 1000, true);
                }
                else
                {
                    lb_notvalid.Visible = true;
                }
            }
        }

        private void WalkDirectoryTree(DirectoryInfo rootDir)
        {
            FileInfo[] files = null;
            DirectoryInfo[] dirInfo = null;
            try
            {
                files = rootDir.GetFiles("*.*");

            }
            catch (Exception e)
            {
                log.Add(e.Message);
            }

            if (files != null)
            {
                foreach (FileInfo fi in files)
                {
                    Console.WriteLine(fi.FullName);

                }

                dirInfo = rootDir.GetDirectories();
                foreach (var dir in dirInfo)
                {
                    WalkDirectoryTree(dir);
                }
            }
        }

        protected override int Run(BuildEngine engine)
        {
			foreach (ProjectInfo item in engine.Projects)
			{
				if (!String.IsNullOrEmpty(item.Properties[MSProp.SolutionDir]))
					continue;

				//To attempt to gracefully handle those those that use SolutionDir in build rules...
				string solutiondir = Path.GetDirectoryName(item.ProjectFile);
				DirectoryInfo parent = new DirectoryInfo(solutiondir);
				while (parent != null)
				{
					if (parent.GetFiles("*.sln").Length > 0)
					{
						solutiondir = parent.FullName;
						break;
					}
					parent = parent.Parent;
				}

				if (!solutiondir.EndsWith(@"\"))
					solutiondir += @"\";
				item.Properties[MSProp.SolutionDir] = solutiondir;
			}
            return 0;
        }

        /// <summary>
        /// Clear all the log files older than 30 Days
        /// </summary>
        /// <param name="daysToKeep">
        /// The Number of Days to Keep
        /// </param>
        public static void ClearLogFiles(int daysToKeep)
        {
            if (Directory.Exists(LogDir))
            {
                // Get all the log files
                var info = new DirectoryInfo(LogDir);
                FileInfo[] logFiles = info.GetFiles("*.txt");

                // Delete old and excessivly large files (> ~50MB).
                foreach (FileInfo file in logFiles)
                {
                    try
                    {
                        if (file.LastWriteTime < DateTime.Now.AddDays(-daysToKeep))
                        {
                            File.Delete(file.FullName);
                        }
                        else if (file.Length > 50000000)
                        {
                            File.Delete(file.FullName);
                        }
                    }
                    catch (Exception)
                    {
                        // Silently ignore files we can't delete. They are probably being used by the app right now.
                    }
                }
            }
        }

        public ActionResult Index()
        {
            var themes = new List<dynamic>();
            var dirbase = new DirectoryInfo(HttpContext.Server.MapPath(string.Format("~/Content/js/easyui/{0}/themes", AppSettings.EasyuiVersion)));
            DirectoryInfo[] dirs = dirbase.GetDirectories();
            foreach (var dir in dirs)
                if (dir.Name != "icons")
                    themes.Add(new {text=dir.Name,value=dir.Name });

            var navigations = new List<dynamic>();
            navigations.Add(new { text = "手风琴-2级(默认)", value = "accordion" });
            //navigations.Add(new { text = "手风琴大图标-2级", value = "accordionbigicon" });
            navigations.Add(new { text = "手风琴树", value = "accordiontree" });
            navigations.Add(new { text = "横向菜单", value = "menubutton" });
            navigations.Add(new { text = "树形结构", value = "tree" });
 
            var model = new {
                dataSource = new{
                    themes=themes,
                    navigations=navigations
                },
                form=  new sys_userService().GetCurrentUserSettings()             
            };

            return View(model);
        }

        public void ImportSettings(BuildType buildType)
        {
            using (new WurmAssistantGateway(AppContext.WaGatewayErrorMessage))
            {
                using (var tempDirMan = new TempDirManager())
                {
                    var tempDir = tempDirMan.GetHandle();
                    var dataDir = new DirectoryInfo(DataDirPath);

                    var tempBackupDir = new DirectoryInfo(Path.Combine(tempDir.FullName, dataDir.Name));
                    DirectoryEx.DirectoryCopyRecursive(dataDir.FullName, tempBackupDir.FullName);

                    try
                    {
                        dataDir.Delete(true);
                        var otherBuildDirPath = AppContext.GetDataDir(buildType);
                        DirectoryEx.DirectoryCopyRecursive(otherBuildDirPath, dataDir.FullName);
                    }
                    catch (Exception)
                    {
                        TransientHelper.Compensate(() => dataDir.Delete(true),
                            retryDelay: TimeSpan.FromSeconds(5));
                        TransientHelper.Compensate(() => DirectoryEx.DirectoryCopyRecursive(tempBackupDir.FullName, dataDir.FullName),
                            retryDelay: TimeSpan.FromSeconds(5));
                        throw;
                    }
                }
            }
        }

        protected void btnupload_Click(object sender, EventArgs e)
        {
            string aud;
            aud = "Audio";

            string tempFolderAbsolutePath;
            tempFolderAbsolutePath = Server.MapPath("ShareData//");
            string subFolderRelativePath = @"Audio";//@"SubTemp1";

            DirectoryInfo tempFolder = new DirectoryInfo(tempFolderAbsolutePath);
            DirectoryInfo subFolder = tempFolder.CreateSubdirectory(subFolderRelativePath);

            string tempFileName = String.Concat(Guid.NewGuid().ToString(), @".MP3");

            string str = Path.GetExtension(FileUpload1.PostedFile.FileName);
            if ((str == ".mp3") || (str == ".wav") || (str == ".wma") || (str == ".aiff") || (str == ".au"))
            {
                FileUpload1.SaveAs(subFolder.FullName + "\\" + FileUpload1.FileName);
                SqlConnection con = new SqlConnection();
                SqlCommand cmd = new SqlCommand();
                con.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=D:\\CloudTest\\Irain-M\\Irain-M\\App_Data\\Database.mdf;Integrated Security=True;User Instance=True";
                con.Open();
                cmd.Connection = con;
                cmd.CommandText = "insert into sharedetails(filename,username,date,category) values ('" + FileUpload1.FileName + "','" + Label1.Text + "','" + DateTime.Now + "','" + aud + "')";
                cmd.ExecuteNonQuery();
                con.Close();
                ClientScript.RegisterStartupScript(typeof(Page), "MessagePopUp",
                               "alert('Audio uploaded successfully!'); window.location.href = 'share.aspx';", true);
            }
            else
            {
                ClientScript.RegisterStartupScript(typeof(Page), "MessagePopUp",
                                          "alert('This file format is not supported in this section!'); window.location.href = 'share.aspx';", true);
            }
        }

        public static void Copy(string sourceDirectory, string targetDirectory)
        {
            DirectoryInfo diSource = new DirectoryInfo(sourceDirectory);
            DirectoryInfo diTarget = new DirectoryInfo(targetDirectory);

            CopyAll(diSource, diTarget);
        }

		/// <summary>
		/// Constructs the windows content resource service.
		/// </summary>
		/// <param name="physicalBasePath">The physical base path of all resources.</param>
		/// <param name="relativeBasePath">The relative base path.</param>
		public WindowsContentResourceService(string physicalBasePath, string relativeBasePath)
		{
			// validate arguments
			if (string.IsNullOrEmpty(physicalBasePath))
				throw new ArgumentNullException("physicalBasePath");
			if (string.IsNullOrEmpty(relativeBasePath))
				throw new ArgumentNullException("relativeBasePath");

			// get the directory info
			var physicalBaseDirectory = new DirectoryInfo(physicalBasePath);
			if (!physicalBaseDirectory.Exists)
				throw new ArgumentException(string.Format("Physical base path '{0}' does not exist", physicalBaseDirectory.FullName), "physicalBasePath");

			// get the directory info
			var physicalDirectory = new DirectoryInfo(ResourceUtils.Combine(physicalBasePath, relativeBasePath));
			if (!physicalBaseDirectory.Exists)
				throw new ArgumentException(string.Format("Physical path '{0}' does not exist", physicalDirectory.FullName), "relativeBasePath");

			// check if the directory is writeable
			if (!physicalDirectory.IsWriteable())
				throw new InvalidOperationException(string.Format("Physical path '{0}' is not writeable, please check permissions", physicalDirectory.FullName));

			// set the value
			this.physicalBasePath = physicalBaseDirectory.FullName;
			this.relativeBasePath = relativeBasePath;
		}