C# 通用应用程序发布检查工具-软件自动更新程序(四)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using AppReleaseCheckTool.Models;
using System.IO;
using System.Windows.Forms;
using System.Xml.Linq;

namespace AppReleaseCheckTool.BL
{
    public class CheckFolderFileBO
    {

        private static CheckFolderFileBO _instance = null;

        public static CheckFolderFileBO Instance()
        {
            if (_instance == null)
            {
                _instance = new CheckFolderFileBO();
            }
            return _instance;
        }

        public FolderFileMessage GetFolderFileMessage
        {
            get;
            set;
        }
        public SetCheckConfigModel CurrSetCheckConfigModel
        {
            get;
            set;
        }
        public bool DisplayFilter
        {
            get;
            set;
        }
        public List<FolderInfoModel> SearchFileAll()
        {
            DisplayFilter = true;
            return SearchFileAll(DisplayFilter);
        }
        public List<FolderInfoModel> SearchFileAll(bool displayFilter)
        {
            DisplayFilter = displayFilter;
            List<FolderInfoModel> list = new List<FolderInfoModel>();
            FolderInfoModel model = null;
            DirectoryInfo dirInfo = new DirectoryInfo(CurrSetCheckConfigModel.CheckRootDir);
            if (dirInfo.Exists)
            {
                model = new FolderInfoModel();

                model.FolderName = dirInfo.Name;
                model.FolderPath = "\\";
                model.ParentFolder = null;
                model.FileList = GetFilterFileInfo(dirInfo, model);
                model.ChildFolder = GetFilterDirectoryInfo(dirInfo, model);
                model.CreateTime = dirInfo.CreationTime;
                model.IsFilter = false;


            }
            list.Add(model);
            return list;
        }


        public List<FolderInfoModel> GetFilterDirectoryInfo(DirectoryInfo currDir,FolderInfoModel parentFolder)
        {
            FolderInfoModel model = null;
            List<FolderInfoModel> list = new List<FolderInfoModel>();
            if (currDir.Exists)
            {
                IEnumerable<DirectoryInfo> dirInfos = currDir.GetDirectories();
                foreach (var item in dirInfos)
                {
                    model = new FolderInfoModel();
                    model.FolderName = item.Name;
                    model.ParentFolder = parentFolder;
                    model.FolderPath = ((System.IO.FileSystemInfo)(item)).FullName.Replace(CurrSetCheckConfigModel.CheckRootDir,"");
                   
                    model.CreateTime = item.CreationTime;
                    model.IsFilter = false;  

                    if (!string.IsNullOrEmpty(CurrSetCheckConfigModel.FilterDir))
                    {
                        if (CurrSetCheckConfigModel.FilterDir.ToLower().IndexOf(item.Name.ToLower()) >= 0)
                        {
                            model.IsFilter = true;              
                        }
                    }
                    if (DisplayFilter)
                    {
                        model.FileList = GetFilterFileInfo(item, model);
                        model.ChildFolder = GetFilterDirectoryInfo(item, model);
                        list.Add(model);
                        GetFolderFileMessage.DirCount++;
                    }
                    else
                    {
                        if (!model.IsFilter)
                        {
                            model.FileList = GetFilterFileInfo(item, model);
                            model.ChildFolder = GetFilterDirectoryInfo(item, model);
                            list.Add(model);
                            GetFolderFileMessage.DirCount++;
                        }
                    }
                }
            }
            return list;
        }

        public List<FileInfoModel> GetFilterFileInfo(DirectoryInfo currDir, FolderInfoModel parentFolder)
        {
            List<FileInfoModel> list = new List<FileInfoModel>();
            IEnumerable<FileInfo> fileInfos = currDir.GetFiles();
            FileInfoModel model = null;
            foreach (var item in fileInfos)
            {
                model = new FileInfoModel();
                model.FilePath = item.DirectoryName;
                model.RelativePath = model.FilePath.Replace(CurrSetCheckConfigModel.CheckRootDir.Substring(0,CurrSetCheckConfigModel.CheckRootDir.Length), "");
                model.FileExt = item.Extension;  
                model.FileName = item.Name;                            
                model.CreateTime = item.LastAccessTime;
                model.IsFilter = false;
                model.ParentFolder = parentFolder;
                model.ModifyTime = item.LastWriteTime;
                model.FileSize = item.Length; 
                if (!string.IsNullOrEmpty(CurrSetCheckConfigModel.FilterExt))
                {
                    model.IsFilter = IsMatchString(CurrSetCheckConfigModel.FilterExt, item.Name);     
                   
                }
                if (!string.IsNullOrEmpty(CurrSetCheckConfigModel.FilterFile) && !model.IsFilter)
                {
                    model.IsFilter = IsMatchString(CurrSetCheckConfigModel.FilterFile, item.Name);
                }
                if (DisplayFilter)
                {
                    list.Add(model);
                    GetFolderFileMessage.FileCount++;
                }
                else
                {
                    if (!model.IsFilter)
                    {
                        list.Add(model);
                        GetFolderFileMessage.FileCount++;
                    }
                }
            }
            return list;
        }

        private bool IsMatchString(string filterStr, string str)
        {
            string[] temp = filterStr.Split(';');
            foreach (var tempstr in temp)
            {
                if (str.IndexOf(tempstr, StringComparison.CurrentCultureIgnoreCase) >= 0)
                {
                    return true;
                }
            }
            return false;

        }

        public void GetFileXml(XElement folderElement, FolderInfoModel folder)
        {
            if (folder.FileList == null || folder.FileList.Count <= 0)
                return;
            foreach (var item in folder.FileList)
            {
                folderElement.Add(item.GetModelXml());
            }
        }

        public void GetFolderXml(XElement folderElement, FolderInfoModel folder)
        {
            XElement currFolderElement = null;
            if (folder.ChildFolder != null && folder.ChildFolder.Count > 0)
            {
                foreach (var item in folder.ChildFolder)
                {
                    currFolderElement = item.GetModelXml();
                    GetFileXml(currFolderElement, item);
                    GetFolderXml(currFolderElement, item);
                    folderElement.Add(currFolderElement);
                    
                }
            }


        }

        public void SaveXml(List<FolderInfoModel> model)
        {
            if (model == null || model.Count <= 0)
                return;
            XElement rootxml = new XElement("AutoUpgrade",
                new XAttribute("ReleaseTime", DateTime.Now.ToString()),
                new XAttribute("Version", "4.0"));
            XElement dirxml =model[0].GetModelXml();
            GetFileXml(dirxml, model[0]);
            GetFolderXml(dirxml, model[0]);
            rootxml.Add(dirxml);
            rootxml.Save(CurrSetCheckConfigModel.OutputDir +"\\" + CurrSetCheckConfigModel.OutputFile);
        }

        




    }
}