コード例 #1
0
        private static bool LoadFile(FileWithParam fwp)
        {
            //проверка
            //корректности имени файла
            if (!FileCheck.CheckFileName(fwp))
            {
                return(false);
            }
            //действительности данных
            if (!FileCheck.CheckValidData(fwp))
            {
                return(false);
            }
            //корректности кодировки
            if (!FileCheck.CheckEncodingXml(fwp))
            {
                return(false);
            }
            //валидации файла
            if (!FileCheck.CheckValidXml(fwp))
            {
                return(false);
            }

            try
            {
                bool loaded = false;

                //словарь вариантов загрузок: ключ и значение (цель делегата)
                Dictionary <string, LoadDelegate> oper = new Dictionary <string, LoadDelegate>
                {
                    { "loadcategory", LoadCategory },
                    { "loadvat", LoadVat },
                    { "loadbrand", LoadBrand },
                    { "loadmodel", LoadModel },
                };

                loaded = oper.ContainsKey(fwp.MethodLoad.ToLower()) ? oper[fwp.MethodLoad.ToLower()](fwp) : LoadError(fwp);

                //switch (fwp.MethodLoad.ToLower())
                //{
                //    case "loadcategory":
                //        loaded = LoadCategory(fwp);
                //        break;
                //    case "loadvat":
                //        loaded = LoadVat(fwp);
                //        break;
                //    default:
                //        loaded = LoadError(fwp);
                //        break;
                //}

                return(loaded);
            }
            catch (Exception ex)
            {
                Log.write(ex.Message);
                return(false);
            }
        }
コード例 #2
0
        /// <summary>
        /// Загузка TextReader с помощью XmlDocument
        /// </summary>
        private static bool GetTextViaXmlDocument(FileWithParam fwp, string xAttr, out TextReader reader)
        {
            string xmlStr = "";

            reader = null;
            try
            {
                XmlDocument  xDoc = new XmlDocument();
                StreamReader sr   = new StreamReader(fwp.FullName, Encoding.GetEncoding(fwp.Encoding.HeaderName));
                try
                {
                    xDoc.Load(sr);
                }
                catch (Exception ex)
                {
                    Log.write(ex.Message);
                    return(false);
                }
                finally
                {
                    sr.Close();
                }

                XmlNode xNode = xDoc.SelectSingleNode(xAttr);
                xmlStr = xNode.OuterXml;
            }
            catch (Exception ex)
            {
                Log.write(ex.Message);
                return(false);
            }

            if (!FileCheck.CheckXmlString(xmlStr))
            {
                return(false);
            }

            reader = new StringReader(xmlStr);
            return(true);
        }
コード例 #3
0
        /// <summary>
        /// Функция, возвращающая список файлов с параметрами
        /// </summary>
        /// <returns></returns>
        public static List <FileWithParam> GetFiles()
        {
            List <FileWithParam> fwps;
            List <LoadRule>      lrs;
            int cnt = 0;

            //шаблоны
            string patterndate = @"(19|20)\d{2}(0[1-9]|1[012])(0[1-9]|[12][0-9]|3[01])";
            string patternnum  = @"\d+";
            string pattern     = patterndate + "_" + patternnum;

            try
            {
                fwps = new List <FileWithParam>();

                string filePath;
                if (!DataBaseManager.GetSettingValue("filePath", out filePath))
                {
                    return(fwps);
                }

                Utils.CreateDir(filePath);

                DirectoryInfo   dir   = new DirectoryInfo(filePath);
                List <FileInfo> files = dir.GetFiles().ToList();

                if (files.Count == 0)
                {
                    return(fwps);
                }

                //правила загрузки
                lrs = Utils.GetLoadRules();

                if (lrs == null)
                {
                    Log.write("Список правил загрузок пустой!");
                    return(fwps);
                }

                if (lrs.Where(x => x.IsActive && !(x.Pattern == null || x.Pattern.Equals(""))).Count() == 0)
                {
                    Log.write("Список правил загрузок некорректен!");
                    return(fwps);
                }

                //создание директорий и запись файлов на диск по правилам загрузки
                if (!CreateDirAndFilesByRules(lrs))
                {
                    return(fwps);
                }

                //прохождение по списку файлов FileInfo
                foreach (FileInfo file in files)
                {
                    FileWithParam fwp = new FileWithParam();
                    fwp.FullName = file.FullName;
                    fwp.Name     = file.Name;

                    fwp.SignFileName    = false;
                    fwp.SignEncodingXml = false;
                    fwp.SignValidData   = false;
                    fwp.SignValidXml    = false;
                    fwp.ErrorMsg        = null;

                    cnt = 0;
                    foreach (LoadRule lr in lrs.Where(x => x.IsActive && !(x.Pattern == null || x.Pattern.Equals(""))).OrderBy(x => x.Ord))
                    {
                        if (Regex.IsMatch(fwp.Name, "^" + lr.Pattern + "$", RegexOptions.IgnoreCase))
                        {
                            cnt++;
                            if (cnt == 1) //первое совпадение в цикле
                            {
                                //корректное имя файла
                                fwp.SignFileName = true;

                                //кодировка xml-файла
                                fwp.Encoding = FileCheck.GetEncoding(fwp);
                                if (fwp.Encoding == null)
                                {
                                    fwp.SignValidData = false; //ошибка действительности данных - прекращение поиска правил
                                    break;
                                }

                                //проверка кодировки
                                fwp.SignEncodingXml = FileCheck.CheckEncoding(fwp);
                                if (!fwp.SignEncodingXml)     //Некорректная кодировка
                                {
                                    fwp.SignValidData = true; //не является ошибкой действительности данных
                                    break;
                                }
                            }

                            XmlDocument  xnldoc  = new XmlDocument();
                            StreamReader strmrdr = new StreamReader(fwp.FullName, System.Text.Encoding.GetEncoding(fwp.Encoding.HeaderName));
                            try
                            {
                                xnldoc.Load(strmrdr);
                                fwp.SignValidData = true;

                                string errMsg;
                                string pathName = lr.Specs.Where(x => x.IsMain).Select(x => x.PathName).First();
                                //валидация xml
                                if (FileCheck.CheckValidate(xnldoc, pathName, out errMsg)) //успешная валдация - правило найдено - прекращение поиска правил
                                {
                                    fwp.CodeRule     = lr.Code;
                                    fwp.MethodLoad   = lr.Method;
                                    fwp.SignValidXml = true;
                                    fwp.ErrorMsg     = null;
                                    fwp.Order        = lr.Ord;
                                    break;
                                }
                                else
                                {
                                    fwp.SignValidXml = false;
                                    fwp.ErrorMsg     = string.IsNullOrEmpty(fwp.ErrorMsg) ? string.Concat(lr.Pattern, ": ", errMsg) : string.Concat(fwp.ErrorMsg, " ", string.Concat(lr.Pattern, ": ", errMsg));
                                }
                            }
                            catch (Exception ex)
                            {
                                //действительность данных
                                fwp.SignValidData = false;
                                fwp.ErrorMsg      = ex.Message;
                                break;
                            }
                            finally
                            {
                                strmrdr.Close();
                            }
                        }
                    }

                    //шаблон: дата
                    if (fwp.SignFileName)
                    {
                        if (Regex.IsMatch(fwp.Name, patterndate, RegexOptions.IgnoreCase))
                        {
                            Match  match = Regex.Match(fwp.Name, patterndate, RegexOptions.IgnoreCase);
                            string dt    = match.Value;
                            fwp.Date = DateTime.ParseExact(dt, "yyyyMMdd", CultureInfo.InvariantCulture);
                        }
                        else
                        {
                            fwp.Date = new DateTime(2999, 12, 31);
                        }
                    }
                    else
                    {
                        fwp.Date = new DateTime(2999, 12, 31);
                    }
                    fwps.Add(fwp);
                }

                //удаление файлов с диска и директорий по правилам загрузки
                DeleteFilesAndDirByRules(lrs);

                return(fwps);
            }
            catch (Exception ex)
            {
                Log.write(ex.Message);
                return(null);
            }
        }