Ejemplo n.º 1
0
 public settings(/*string xml, */ string options_folder, string save_folder, cfg_data cfg_up, string cfg_folder)
 {
     cfg.options      = cfg_up.options;
     cfg.prepositions = cfg_up.prepositions;
     cfg.stop_words   = cfg_up.stop_words;
     cfg.coefficients = cfg_up.coefficients;
     cfg.coefficients_volume_and_mass = cfg_up.coefficients_volume_and_mass;
     get_category(cfg_folder + "\\Соотнесение категорий.csv");
     get_name_of_category(cfg_folder + "\\id категории.csv");
 }
Ejemplo n.º 2
0
        public void tre_threads_options()
        {
            cfg_data cfg = new cfg_data();

            cfg.options      = f.tre_conf.head_options;
            cfg.prepositions = Form1.prepositions;
            //cfg.stop_words = Form1.stop_words;
            cfg.coefficients = f.full.coefficient;
            cfg.coefficients_volume_and_mass = f.full.coefficient_package_mass;

            string[] files_xml = {};
            try
            {
                files_xml = Directory.GetDirectories(f.tre_conf.tre_folder + "\\XML");
            }
            catch { MessageBox.Show("Не правильный путь к основной папке"); }

            bool th = ThreadPool.SetMaxThreads(f.threads, f.threads);


            foreach (string dir in files_xml)
            {
                object[] hi = { "" };
                try
                {
                    object[] hi_tmp = { Directory.GetFiles(dir).First(), dir + "\\Tmp_files", dir + "\\Dop_file", cfg, "cfg", f.desc_save.lines_description, f.desc_save.options };
                    hi = hi_tmp;
                    object i = new object();
                    lock (i) {
                        ThreadPool.QueueUserWorkItem(f.stl.make_op, hi);
                    }
                }
                catch
                {
                    MessageBox.Show("Ошибка формирования доп файла, файл xml:" + Convert.ToString(hi[0]));
                }
                //Thread.Sleep(14000);
            }
        }
Ejemplo n.º 3
0
        public void make_op(object ob)
        {
            string[,] sim_to_ch = null;;
            try { sim_to_ch = functions_stl.get_sim_to_ch("cfg\\Список подстановки.txt"); }
            catch { MessageBox.Show("Не удалось загрузить Список подстановки.txt"); }

            object[]      inf              = ob as object[];
            string        xml              = Convert.ToString(inf[0]);
            string        folder_options   = Convert.ToString(inf[1]);
            string        save             = Convert.ToString(inf[2]);
            cfg_data      cfg              = (cfg_data)inf[3];
            string        cfg_folder       = Convert.ToString(inf[4]);
            List <string> tmpl_description = (List <string>)inf[5];

            string [] key_words = (string[])inf[6];

            const uint shift = 2;

            settings       sets    = new settings(/*xml, */ folder_options, save, cfg, cfg_folder);
            List <Options> options = new List <Options>();                      // опции всех файлов
            List <int>     index   = new List <int>();                          // список индексов из данных парсера

            string[] files_opions = Directory.GetFiles(folder_options);         // список файлов
            if (files_opions.Length == 0)
            {
                return;
            }

            string name_f     = "";
            string save_uload = "";

            List <string> title_tmp = new List <string>();
            List <string> title     = new List <string>();
            List <string> unload    = new List <string>();

            Regex         get_line = new Regex("(.+)$", RegexOptions.Multiline);
            string        words    = "";
            StringBuilder sb       = new StringBuilder();

            foreach (string file_option in files_opions)
            {
                StringBuilder normal_file = new StringBuilder();
                title_tmp.Clear();
                name_f = Path.GetFileNameWithoutExtension(file_option);
                string fileText = "";
                try { fileText = System.IO.File.ReadAllText(file_option, Encoding.Default); }
                catch { MessageBox.Show("Не найден фаил описания"); }

                // -------------------------------------------- Заголовок --------------------------------------------
                Regex sub_string = new Regex(";");
                words = get_line.Match(fileText).Groups[1].Value;

                string[]   title_l         = sub_string.Split(words);
                List <int> not_found_index = new List <int>();       // Индексы столбцов не найденных в заголовке

                for (int il = 0; il < title_l.Length; il++)
                {
                    bool fine = false;
                    if (il == shift)
                    {
                        /*title.Add("PROIZVODITEL"); */
                        title_tmp.Add("NAME"); title_tmp.Add("FULL_NAME"); title_tmp.Add("EKSPORT");
                        title_tmp.Add("DESCRIPTION"); title_tmp.Add("LENGTH_PACK"); title_tmp.Add("WIDTH_PACK"); title_tmp.Add("HEIGHT_PACK"); title_tmp.Add("WEIGHT_V"); title_tmp.Add("WEIGHT");
                        title_tmp.Add("DELIVERY_PACKAGE_TYPE"); title_tmp.Add("DELIVERY_PACKAGE");
                    }

                    foreach (string[] it in sets.cfg.options)
                    {
                        if ((title_l[il] == "\"" + it[0] + "\"") || (title_l[il] == it[0]))
                        {
                            fine = true;
                            title_tmp.Add(it[1]);   // заголовок из наденных свойств
                            break;
                        }
                    }

                    if (!fine)
                    {
                        not_found_index.Add(il);
                        unload.Add(title_l[il]);      // не найденные свойства
                    }
                }

                foreach (string s in unload)
                {
                    save_uload += s + "\r\n";
                }

                int i = 0;
                foreach (string option in title_tmp)
                {
                    bool is_tl = false; i++;
                    foreach (string tl in title)
                    {
                        if (option == tl)
                        {
                            is_tl = true;
                            break;
                        }
                    }
                    if (!is_tl)
                    {
                        title.Add(option);
                    }
                    if (i == shift)
                    {
                        /*title.Add("PROIZVODITEL"); */
                        title.Add("NAME"); title.Add("FULL_NAME"); title.Add("EKSPORT");
                        title.Add("DESCRIPTION"); title.Add("LENGTH_PACK"); title.Add("WIDTH_PACK"); title.Add("HEIGHT_PACK"); title.Add("WEIGHT_V"); title.Add("WEIGHT");
                        title.Add("DELIVERY_PACKAGE_TYPE"); title.Add("DELIVERY_PACKAGE");
                    }
                }
                // -------------------------------------------- Заголовок --------------------------------------------

                title = title.Distinct().ToList();
                foreach (string item in title_tmp)
                {
                    normal_file.Append(item + ";");
                }
                normal_file.Append("\r\n");  // файл с правильным заголовком

                Regex           manual_get_line = new Regex("https(.*)", RegexOptions.Multiline);
                MatchCollection lines           = get_line.Matches(fileText);
                StringBuilder   str_bl          = new StringBuilder();
                string          buf;


                // ---------------------------------- Удаление символов новои строки ---------------------------------
                for (i = 1; i < lines.Count; i++)
                {
                    if (i == lines.Count - 1)
                    {
                        str_bl.Append(lines[i] + "\r\n"); break;
                    }
                    if (manual_get_line.IsMatch(lines[i + 1].Value))
                    {
                        str_bl.Append(lines[i] + "\r\n");
                    }
                    else
                    {
                        buf  = lines[i].Value;
                        buf  = buf.Replace("\r\n", "");  buf = buf.Replace("\r", ""); buf = buf.Replace("\n", "");
                        buf += "__";
                        str_bl.Append(buf);
                    }
                }
                // ---------------------------------- Удаление символов новои строки ---------------------------------

                lines = get_line.Matches(str_bl.ToString());

                Regex  r_celas = new Regex(";");
                string rn;
                foreach (Match line in lines)
                {
                    string[] cells = r_celas.Split(line.Value);
                    buf = "";
                    for (i = 0; i < cells.Length; i++)
                    {
                        if (i == shift)
                        {
                            buf += ";;;;;;;;;;;";
                        }
                        if (sets.equal(i, not_found_index))     // - пропуск не наиденных столбцов
                        {
                            continue;
                        }
                        buf += cells[i] + ";";
                    }
                    normal_file.Append(buf);
                    rn = normal_file[normal_file.Length - 3].ToString() + normal_file[normal_file.Length - 2];
                    if (rn != "\r\n")
                    {
                        normal_file.Append("\r\n");
                    }
                    normal_file.Remove(normal_file.Length - 1, 1);
                }

                MatchCollection time = get_line.Matches(normal_file.ToString());

                /*if (save_uload != "")
                 * {
                 *  File.WriteAllText("unload.txt", save_uload);
                 *  //MessageBox.Show("Не все поля заголовка были найденны.\r\nНедостающие свойства сохнаненны в файл unload.txt");
                 * }*/

                //File.WriteAllText("normal_file.csv", normal_file.ToString(), Encoding.Default);
                //MessageBox.Show("hi");

                var config = new CsvConfiguration(CultureInfo.InvariantCulture)
                {
                    Delimiter         = ";",
                    HeaderValidated   = null,
                    MissingFieldFound = null,
                    Encoding          = Encoding.GetEncoding(1251),
                    //var info = new List<string>();
                    BadDataFound = data => {
                        //info.Add(data.RawRecord);
                    },
                };
                List <Options> options_values = new List <Options>();
                StreamReader   reader         = new StreamReader(new MemoryStream(Encoding.GetEncoding(1251).GetBytes(normal_file.ToString())), Encoding.GetEncoding(1251));
                using (var csv = new CsvReader(reader, config))
                {
                    var li = csv.GetRecords <Options>();
                    options_values = li.ToList();
                    options.AddRange(options_values);
                    options_values = null;
                }
            }

            foreach (var tl in title)
            {
                sb.Append(tl + ";");
            }
            sb.Remove(sb.Length - 1, 1);        //  удаление последнего разделительного символа
            sb.Append("\r\n");

            //                                  //  удаление кавычек
            foreach (Options option in options)
            {
                if (option.id == "2624611")
                {
                    //
                }
            }
            foreach (Options option in options)
            {
                option.id = Regex.Replace(option.id, "\"", "");
            }

            // --------------------------- добавление в список индексов ---------------------------
            Regex r_id = new Regex("(.*)\\/(\\d*)");

            foreach (Options option in options)
            {
                try
                {
                    Match m_id = r_id.Match(option.id);
                    int   id   = Convert.ToInt32(m_id.Groups[2].Value);
                    index.Add(id);
                    option.artnumber = id.ToString();
                }
                catch
                {
                }
            }
            // --------------------------- добавление в список индексов ---------------------------

            // получение данных из хмл файла учитывая только индексы которые есть в списке options
            Get_xml xml_data = new Get_xml(xml, index);

            // --------------------------- формирование габаритов и веса --------------------------
            foreach (Options option in options)
            {
                option.get_abc_weight(sets.cfg.coefficients_volume_and_mass, ref xml_data.get_xml_data);
            }
            // --------------------------- формирование габаритов и веса --------------------------

            // --------------------------- выборка из массива классов свойств в string bufer для сохранения в текстовый файл ---------------------------
            foreach (Options option in options)
            {
                Xml_offer time_xml_line = xml_data.get_xml_data.Find(data => data.id == option.artnumber);
                time_xml_line.to_asci(sim_to_ch);

                if (time_xml_line != null)
                {
                    option.proizvoditel = time_xml_line.vendor;
                }
                else
                {
                    continue;
                }

                char[] se = { '_', '_' };
                // --------------------------- формироание описания ---------------------------
                Dictionary <string, string> words_key = new Dictionary <string, string>();

                if (key_words == null)
                {
                    key_words = new string[0];
                }
                foreach (var key in key_words)
                {
                    if (functions_stl.get_property(key, option) != "" && functions_stl.get_property(key, option) != null)
                    {
                        words_key.Add(key, functions_stl.get_property(key, option));
                    }
                }

                if (words_key.ContainsKey("SOSTAV"))
                {
                    words_key["SOSTAV"] = words_key["SOSTAV"].Split(se)[0];
                }

                if (words_key.ContainsKey("SERIYA"))
                {
                    words_key["SERIYA"] = words_key["SERIYA"].Split(se)[0];
                }

                if (words_key.ContainsKey("MATERIAL"))
                {
                    string material = option.material != "" ? option.material : option.sostav;
                    if (material == "")
                    {
                        material = time_xml_line.composition;
                    }
                    words_key["MATERIAL"] = material;
                }

                if (key_words.Contains("NAME"))
                {
                    words_key["NAME"] = time_xml_line.name_short(time_xml_line.name, sets.cfg.prepositions, sets.cfg.stop_words);
                }
                if (key_words.Contains("FULL_NAME"))
                {
                    words_key["FULL_NAME"] = time_xml_line.name;
                }
                if (key_words.Contains("PRICE"))
                {
                    words_key["PRICE"] = Convert.ToString(time_xml_line.price * sets.get_coefficient(time_xml_line.price));
                }
                if (key_words.Contains("ID_CATEGORY"))
                {
                    words_key["ID_CATEGORY"] = sets.get_name_of_category(time_xml_line.category);
                }


                option.description = classes.functions_stl.make_description(tmpl_description, words_key);

                // --------------------------- формироание описания ---------------------------
                foreach (string tl in title)
                {
                    string value = functions_stl.get_property(tl.ToLower(), option);

                    if (tl == "WEIGHT_V_GR" && option.WEIGHT_V_GR != "")
                    {
                    }

                    // ------------------------------------------- игнорирование дубля -------------------------------------------
                    string[] cut_double = { "" };
                    if (tl == "SERIYA" || tl == "PRICE_FOR_THE_ONE" || tl == "PRICE_FOR" || tl == "PRICE_FOR_" || tl == "SOSTAV" || tl == "SIZE_2")
                    {
                        //words = get_line.Match(option.get_property(tl.ToLower(), option)).Groups[1].Value;
                        if (value != "")
                        {
                            cut_double = value.Split(se);
                        }

                        sb.Append(cut_double[0] + ";");
                    }
                    // ------------------------------------------- игнорирование дубля -------------------------------------------
                    else if (tl == "LENGTH_PACK" || tl == "WIDTH_PACK" || tl == "HEIGHT_PACK" || tl == "WEIGHT_V" || tl == "WEIGHT")
                    {
                        if (value == "0")
                        {
                            sb.Append(";");
                        }
                        else
                        {
                            sb.Append(value + ";");
                        }
                    }
                    else if (tl == "DIAMETR_PISHUSHCHEGO_UZLA_MM")
                    {
                        value = value.Replace(".", ",");
                        sb.Append(value + ";");
                    }
                    else
                    {
                        sb.Append(value + ";");
                    }
                }

                sb.Remove(sb.Length - 1, 1);        // удаление последнего разделительного символа
                sb.Append("\r\n");
                //string hi = nameof(option);
            }

            options.Clear();

            List <Options_stl> options_last = new List <Options_stl>();
            List <Options_stl> options_new  = new List <Options_stl>();

            string[] last_artnumbers, new_artnumbers, new_id, equal;
            string   file_last_option = Directory.GetFiles(save).FirstOrDefault();

            if (file_last_option != null)
            {
                // ---------------------------------------------------- загрузка нового фаила с описанием -----------------------------------------------------
                var config = new CsvConfiguration(CultureInfo.InvariantCulture)
                {
                    Delimiter         = ";",
                    HeaderValidated   = null,
                    MissingFieldFound = null,
                    Encoding          = Encoding.GetEncoding(1251),
                    //var info = new List<string>();
                    BadDataFound = data => {
                        //info.Add(data.RawRecord);
                    },
                };
                using (var reader = new StringReader(sb.ToString()))
                    using (var csv = new CsvReader(reader, config))
                    {
                        var li = csv.GetRecords <Options_stl>();
                        options_new = li.ToList();
                    }
                // ---------------------------------------------------- загрузка нового фаила с описанием -----------------------------------------------------

                // -------------------------------------------------- загрузка предидущего фаила с описанием --------------------------------------------------
                using (var reader = new StreamReader(file_last_option, Encoding.GetEncoding(1251)))
                    using (var csv = new CsvReader(reader, config))
                    {
                        var li = csv.GetRecords <Options_stl>();
                        options_last = li.ToList();
                    }
                // -------------------------------------------------- загрузка предидущего фаила с описанием --------------------------------------------------

                new_artnumbers  = Options_stl.get_artbumbers(options_new);
                last_artnumbers = Options_stl.get_artbumbers(options_last);
                new_id          = new_artnumbers.Except(last_artnumbers).ToArray();     //  нахождение новых позиции
                //equal  = new_artnumbers.Intersect(last_artnumbers).ToArray();           //  нахождение совпадении

                //  добавление новых элементов
                Options_stl new_op = new Options_stl();
                foreach (string st in new_id)
                {
                    new_op = options_new.Find(l => l.artnumber == st);
                    options_last.Add(new_op);
                }

                // ------------------------------------------------------------ формирование фаила ------------------------------------------------------------
                // - заголовок
                sb.Clear();
                foreach (string item in title)
                {
                    sb.Append(item + ";");
                }
                sb.Remove(sb.Length - 1, 1);
                sb.Append("\r\n");
                // - заголовок

                string value;
                foreach (Options_stl op in options_last)
                {
                    foreach (string tl in title)
                    {
                        value = op.get_property(tl.ToLower(), op);
                        sb.Append(value + ";");
                    }
                    sb.Remove(sb.Length - 1, 1);
                    sb.Append("\r\n");
                }
                // ------------------------------------------------------------ формирование фаила ------------------------------------------------------------
            }
            // --------------------------- выборка из массива классов свойств в string bufer для созранения в текстовый файл ---------------------------
            //сохраняем говый файл
            File.WriteAllText(save + "\\" + Path.GetFileNameWithoutExtension(xml) + ".csv", sb.ToString(), Encoding.GetEncoding(1251));

            // удаление файлов парсера
            foreach (string file_option in files_opions)
            {
                File.Delete(file_option);
            }
        }