void test_Mtch_3() { Log.set(" test_Mtch_3: Rule 5 и Group < C235, Pl30 >"); rule = new Rule.Rule(5); ElmAttSet.ElmAttSet elm = new ElmAttSet.ElmAttSet( "ID56A7442F-0000-0D74-3134-353338303236", "C235", "Steel", "Pl30", 0, 0, 0, 1001); Dictionary<string, ElmAttSet.ElmAttSet> els = new Dictionary<string, ElmAttSet.ElmAttSet>(); els.Add(elm.guid, elm); List<string> guids = new List<string>(); guids.Add(elm.guid); var model = new Model.Model(); model.setElements(els); model.getGroups(); var gr = model.elmGroups[0]; //6/4/17 TST.Eq(gr.guids.Count, 1); //6/4/17 TST.Eq(gr.mat, "c235"); //6/4/17TST.Eq(gr.prf, "pl30"); var doc = Docs.getDoc("Полоса СтальхолдингM"); var csDP = new Dictionary<SType, string>(); //31/3 csFPs = rule.Parser(FP.type.CompSet, doc.LoadDescription); // 2/4 Comp comp1 = new Comp(doc, 2, csDP); // 2/4 Comp comp2 = new Comp(doc, 12, csDP); // 2/4 List<Comp> comps = new List<Comp> { comp1, comp2 }; // 2/4 CS cs = new CS("test_CS", null, rule, doc.LoadDescription, comps); // 2/4 TST.Eq(cs.csDP.Count, 4); //////////////////////////TST.Eq(comp1.isMatch(gr, rule), false); //////////////////////////TST.Eq(comp2.isMatch(gr, rule), true); Log.exit(); }
/// <summary> /// getNEWcs(Supplier, Group) - return CompSet could be supplied by supl, or null if not available /// </summary> /// <param name="selSupl"></param> /// <param name="grOLD"></param> /// <returns></returns> internal CmpSet getNEWcs(Supplier supl, Gr group) { string grCSname = group.CompSetName; CmpSet cs; try { cs = new CmpSet(grCSname, this); } catch { return null; } //////////if (CompSets.Count == 0) //////////{ //////////} //////////var cs = CompSets.Find(x => x.name == grCSname); //////////if (cs != null) return cs; // нашел CS с тем же именем! // в дальнейшем тут вставить подбор CompSet по-компонентно с учетом Rule.synonyms // это означает, что, хотя у CS другое название, его разрешено использовать Правилами. var mod = MainWindow.model; if (mod.Rules.Count == 0) return null; // тут надо загрузить Правила из TSmatchINFO.xlsx/Rules Rule.Rule rule = null; if (group.match != null) rule = group.match.rule; cs = CompSets.Find(x => x.name == rule.CompSet.name); if (cs != null) return cs; // true - found CompSet.name from this Suppler //.. по крайней мере, имя отличается -- проверим по-компонентно все прайс-листы с Match //.. еще не написано return cs; }
bool isMatchGrRule(SType stype, ElmAttSet.Group gr, Rule.Rule rule) { if (rule == null || !fps.ContainsKey(stype)) { return(true); } var ruleSyns = rule.synonyms; string comMatPrf = fps[stype].pars[0].par.ToString(); string grMatPrf = stype == SType.Material ? gr.mat : gr.prf; if (grMatPrf == comMatPrf) { return(true); } if (ruleSyns != null && ruleSyns.ContainsKey(stype)) { List <string> Syns = ruleSyns[stype].ToList(); if (!Lib.IContains(Syns, comMatPrf) || !Lib.IContains(Syns, grMatPrf)) { return(false); } string c = strExclude(comMatPrf, Syns); string g = strExclude(grMatPrf, Syns); //27/3 if(c == g) return true; return(c.Contains(g)); ////////////////var p1 = Params(Syns, comMatPrf, ); //// 27/3 //////var p2 = Params(Syns, grMatPrf); ////////////////bool b = p1 != p2 && stype == SType.Material; return(Params(Syns, comMatPrf) == Params(Syns, grMatPrf)); } return(false); }
bool isMatchGrRule(SType stype, ElmAttSet.Group gr, Rule.Rule rule) { if (rule == null || !compDP.dpar.ContainsKey(stype)) { return(true); } var ruleSyns = rule.synonyms; string comMatPrf = viewComp_(stype); string grMatPrf = stype == SType.Material ? gr.mat : gr.prf; if (grMatPrf.Contains("ш2") && comMatPrf.Contains("ш2")) { log.Info("--"); //5/4 } if (ruleSyns != null && ruleSyns.ContainsKey(stype)) { List <string> Syns = ruleSyns[stype].ToList(); if (!Lib.IContains(Syns, comMatPrf) || !Lib.IContains(Syns, grMatPrf)) { return(false); } string c = strExclude(comMatPrf, Syns); string g = strExclude(grMatPrf, Syns); if (c == g) { return(true); } return(c.Contains(g)); ////////////////var p1 = Params(Syns, comMatPrf, ); //// 27/3 //////var p2 = Params(Syns, grMatPrf); ////////////////bool b = p1 != p2 && stype == SType.Material; //31/3//////////return Params(Syns, comMatPrf) == Params(Syns, grMatPrf); } return(comMatPrf == grMatPrf); }
public CompSet(string _name, Rule.Rule rule, string LoadDescriptor, List <Comp> comps = null) { name = _name; csFPs = rule.Parser(FP.type.CompSet, LoadDescriptor); if (comps != null) { Components = comps; } }
public void UT_Mtch() { boot.Init(); var model = mod.sr.SetModel(boot, initSupl: false); Assert.IsTrue(model.elmGroups.Count > 0); Assert.IsTrue(model.Rules.Count > 0); var Rules = model.Rules.ToList(); var grps = model.elmGroups.ToList(); // test 1 Уголок L50x5 -> цена 7 209 руб Rule.Rule rule = Rules.Find(x => x.sCS.Contains("Уголок")); Group.Group gr = grps.Find(x => x.Prf.Contains("L")); if (rule != null && gr != null) { rule.Init(); var m = new Mtch(gr, rule); Assert.IsTrue(gr.totalPrice > 7000); double rubPerKg = gr.totalPrice / gr.totalWeight; Assert.IsTrue(rubPerKg > 20); } // test 2 Полоса -30 из Листа ЛСС rule = Rules.Find(x => x.sCS.Contains("Лист")); gr = grps.Find(x => x.Prf.Contains("—")); if (rule != null && gr != null) { rule.Init(); var m = new Mtch(gr, rule); Assert.IsTrue(gr.totalPrice > 7000); double rubPerKg = gr.totalPrice / gr.totalWeight; Assert.IsTrue(rubPerKg > 20); } // test 3 Бетон rule = Rules.Find(x => x.sCS.Contains("бетон")); gr = grps.Find(x => x.mat.Contains("b")); if (rule != null && gr != null) { rule.Init(); var m = new Mtch(gr, rule); Assert.IsTrue(gr.totalPrice > 7000); double rubPerM3 = gr.totalPrice / gr.totalVolume; //.totalWeight; Assert.IsTrue(rubPerM3 > 2000); } //foreach (var gr in model.elmGroups) //{ // Assert.IsTrue(model.Rules.Count > 0); // foreach (var rule in model.Rules) // { // Assert.IsNotNull(rule.CompSet.Supplier); // Assert.IsTrue(rule.CompSet.Components.Count > 0); // Mtch _match = new Mtch(gr, rule); // } //} FileOp.AppQuit(); }
public static IRuleConfig GetPageRule(Stream stream) { IRuleConfig pageRule = null; using (JsonReader jsonReader = new JsonTextReader(new StreamReader(stream))) { JObject jObject = JObject.Load(jsonReader); var jTokens = jObject["Pages"]?.AsJEnumerable(); if (jTokens != null) { var _pageRule = new RuleConfig(); foreach (var jToken in jTokens) { PageType pageType; if (!Enum.TryParse(jToken?.Value <string>("PageType"), out pageType)) { continue; } Page page = new Page(); if (Boolean.TryParse(jToken?.Value <string>("UseProxy"), out bool useProxy)) { page.UseProxy = useProxy; } var jRules = jToken["Rules"].AsJEnumerable(); foreach (var jRule in jRules) { Rule.Rule rule = new Rule.Rule() { Name = jRule?.Value <string>("Name"), XPath = jRule?.Value <string>("XPath"), Fun = (Rule.Rule.RuleFun)Enum.Parse(typeof(Rule.Rule.RuleFun), jRule?.Value <string>("Fun")), Param = jRule?.Value <string>("Param"), }; page.Add(rule); } _pageRule.AddRule(pageType, page); } pageRule = _pageRule; } } return(pageRule); }
///////////////////// <summary> ///////////////////// setComp(doc) - fill price list of Components from doc ///////////////////// setComp(doc_name) - overload ///////////////////// </summary> ///////////////////// <param name="doc">price-list</param> ///////////////////// <returns>List of Components</returns> ///////////////////// <history>26.3.2016 ///////////////////// 3.4.2016 - setComp(doc_name) overload ///////////////////// 8.4.2016 - remove unnecteesary fields - bug fix ///////////////////// 14.4.2016 - field mat = Material fill ///////////////////// </history> //////////////////public static List<Component> setComp(string doc_name) //////////////////{ return setComp(Docs.getDoc(doc_name)); } //////////////////public static List<Component> setComp(Docs doc) //////////////////{ ////////////////// Log.set("setComp(" + doc.name + ")"); ////////////////// List<int> docCompPars = Lib.GetPars(doc.LoadDescription); ////////////////// //-- заполнение массива комплектующих Comps из прайс-листа металлопроката ////////////////// List<Component> Comps = new List<Component>(); ////////////////// for (int i = doc.i0; i <= doc.il; i++) ////////////////// { ////////////////// try ////////////////// { ////////////////// string descr = doc.Body.Strng(i, docCompPars[0]); ////////////////// double lng = 0; ////////////////// //-- разбор параметров LoadDescription ////////////////// List<int> strPars = Lib.GetPars(descr); ////////////////// string docDescr = doc.LoadDescription; ////////////////// int parShft = 0; ////////////////// while (docDescr.Contains('/')) ////////////////// { ////////////////// string[] s = doc.LoadDescription.Split('/'); ////////////////// List<int> c = Lib.GetPars(s[0]); ////////////////// int pCol = c[c.Count() - 1]; // колонка - последний параметр до '/' ////////////////// List<int> p = Lib.GetPars(s[1]); ////////////////// lng = strPars[p[0] - 1]; // длина заготовки = параметр в str; индекс - первое число после '/' // 29/3/2017 ///// docDescr = docDescr.Replace("/", ""); // устарело ///// parShft++; ////////////////// } ////////////////// if (lng == 0) ////////////////// lng = doc.Body.Int(i, docCompPars[1]) / 1000; // для lng указана колонка в LoadDescription ////////////////// double price = doc.Body.Double(i, docCompPars[2] + parShft); ////////////////// double wgt = 0.0; //!!! времянка -- пока вес будем брать только из Tekla ////////////////// string mat = ""; //!!! времянка -- материал нужно извлекать из description или описания - еще не написано! ////////////////// Comps.Add(new Component(descr, mat, lng, wgt, price)); ////////////////// } ////////////////// catch { Msg.F("Err in setComp", doc.name); } ////////////////// } ////////////////// Log.exit(); ////////////////// return Comps; //////////////////} public bool isMatch(ElmAttSet.Group gr, Rule.Rule rule = null) //25/3 Dictionary<SecTYPE,List<string>> ruleFPs = null) { if (!isMatchGrRule(SType.Material, gr, rule)) { return(false); } if (!isMatchGrRule(SType.Profile, gr, rule)) { return(false); } return(true); }
///////////////////// <summary> ///////////////////// setComp(doc) - fill price list of Components from doc ///////////////////// setComp(doc_name) - overload ///////////////////// </summary> ///////////////////// <param name="doc">price-list</param> ///////////////////// <returns>List of Components</returns> ///////////////////// <history>26.3.2016 ///////////////////// 3.4.2016 - setComp(doc_name) overload ///////////////////// 8.4.2016 - remove unnecteesary fields - bug fix ///////////////////// 14.4.2016 - field mat = Material fill ///////////////////// </history> //////////////////public static List<Component> setComp(string doc_name) //////////////////{ return setComp(Docs.getDoc(doc_name)); } //////////////////public static List<Component> setComp(Docs doc) //////////////////{ ////////////////// Log.set("setComp(" + doc.name + ")"); ////////////////// List<int> docCompPars = Lib.GetPars(doc.LoadDescription); ////////////////// //-- заполнение массива комплектующих Comps из прайс-листа металлопроката ////////////////// List<Component> Comps = new List<Component>(); ////////////////// for (int i = doc.i0; i <= doc.il; i++) ////////////////// { ////////////////// try ////////////////// { ////////////////// string descr = doc.Body.Strng(i, docCompPars[0]); ////////////////// double lng = 0; ////////////////// //-- разбор параметров LoadDescription ////////////////// List<int> strPars = Lib.GetPars(descr); ////////////////// string docDescr = doc.LoadDescription; ////////////////// int parShft = 0; ////////////////// while (docDescr.Contains('/')) ////////////////// { ////////////////// string[] s = doc.LoadDescription.Split('/'); ////////////////// List<int> c = Lib.GetPars(s[0]); ////////////////// int pCol = c[c.Count() - 1]; // колонка - последний параметр до '/' ////////////////// List<int> p = Lib.GetPars(s[1]); ////////////////// lng = strPars[p[0] - 1]; // длина заготовки = параметр в str; индекс - первое число после '/' // 29/3/2017 ///// docDescr = docDescr.Replace("/", ""); // устарело ///// parShft++; ////////////////// } ////////////////// if (lng == 0) ////////////////// lng = doc.Body.Int(i, docCompPars[1]) / 1000; // для lng указана колонка в LoadDescription ////////////////// double price = doc.Body.Double(i, docCompPars[2] + parShft); ////////////////// double wgt = 0.0; //!!! времянка -- пока вес будем брать только из Tekla ////////////////// string mat = ""; //!!! времянка -- материал нужно извлекать из description или описания - еще не написано! ////////////////// Comps.Add(new Component(descr, mat, lng, wgt, price)); ////////////////// } ////////////////// catch { Msg.F("Err in setComp", doc.name); } ////////////////// } ////////////////// Log.exit(); ////////////////// return Comps; //////////////////} #endif public bool isMatch(Group.Group gr, Rule.Rule rule = null) { if (!isMatchGrRule(SType.Material, gr, rule)) { return(false); } if (!isMatchGrRule(SType.Profile, gr, rule)) { return(false); } return(true); }
////////////////public CompSet(string _name, List<Component.Component> _comps, Supl _supl, Docs _doc, List<FP> _csFPs) ////////////////{ //////////////// this.name = _name; //////////////// this.Components = _comps; //////////////// this.Supplier = _supl; //////////////// this.doc = _doc; //////////////// this.csFPs = _csFPs; ////////////////} public CompSet(string _name, Supl _supl, Rule.Rule _rule) { name = _name; Supplier = _supl; doc = getCSdoc(Supplier, _name); csFPs = _rule.Parser(FP.type.CompSet, doc.LoadDescription); for (int i = doc.i0; i < doc.il; i++) { Comp comp = new Comp(doc, i, csFPs); Components.Add(comp); } }
public void UT_PriceGr_Msg() { // Assign boot.Init(); Rule.Rule rule = new Rule.Rule(); rule.sSupl = "СтальХолдинг"; rule.sCS = "Полоса"; rule.text = "М: C245=C255 ; Профиль: Полоса горячекатаная = PL = — *x*;"; ElmGr gr = new ElmGr(); gr.SupplierName = rule.sSupl; gr.guids = new List <string>() { "guid1", "guid2" }; // test 1: Msg.F("Rules not initialyzed") English string s = sub_PriceGr(mod, gr, "en"); Assert.AreEqual("Rules in Model were not initialyzed", s); // test 2: Msg.F("Rules not initialyzed") Russian s = sub_PriceGr(mod, gr, "ru"); Assert.AreEqual("Не инциированы правила модели", s); // test 3: Rules initialyzed, works with CompSet and Components, Rule, MsgF Wrong LoadDescriptor gr.Prf = "I20"; gr.prf = "i20"; rule.text = "Профиль: Балка =I*"; string comp_txt = "Балка 20"; rule.ruleDP = new DPar.DPar(rule.text); rule.synonyms = rule.RuleSynParse(rule.text); // var syns = rule.synonyms[Section.Section.SType.Profile].ToList(); List <Comp> comps = new List <Comp>() { new Comp(new DP("Prf:I10; Price:23456")), new Comp(new DP("Prf:I20; Price:34567")) }; Supl supl = new Supl("СтальХолдинг", init: false); string LoadDescriptor = "M:1; опис:3; профиль:2; цена: 4; Ед: руб/т"; CS cs = new CS("Балка", supl, LoadDescriptor, comps); Comp comp = new Comp(); comp.compDP = new DP("Prf: " + comp_txt); mod.Rules.Add(rule); rule.CompSet = cs; s = sub_PriceGr(mod, gr, "en", _prefix: "Msg.W: "); Assert.AreEqual("CompSet_wrong_LoadDescriptor", s); FileOp.AppQuit(); }
////////////// private void test_getSectionText() ////////////// { ////////////// Log.set("test_getSectionTest(Section.Material, text"); //28/5/////////////// 7/3/2017 ///////////////// TST.Eq(getSectionText(FP.Section.Material, "Профиль: L 20 x 5; M: C245; Price: 2690"), "c245"); ////////////// Log.exit(); ////////////// } //////////////private void test_isSectionMatch() //////////////{ ////////////// Log.set("isSectionMatch(Section.Material, C245, rule.text)"); ////////////// /////// 7/3/2017 //// bool ok = isSectionMatch(FP.Section.Material, "C245", "Профиль: L * x * ст*; длина: * = * м; M: ст *;"); ////////////// Log.exit(); //////////////} private void test_Mtch_1() { Log.set(" test_Mtch_1: Rule 4 и Group<C255, L20x4>"); Rule.Rule rule = new Rule.Rule(4); ElmAttSet.ElmAttSet el = new ElmAttSet.ElmAttSet( "ID56A7442F-0000-0D70-3134-353338303236", "C245", "Steel", "Уголок20X4", 0, 0, 0, 1000); Dictionary<string, ElmAttSet.ElmAttSet> els = new Dictionary<string, ElmAttSet.ElmAttSet>(); els.Add(el.guid, el); List<string> guids = new List<string>(); guids.Add(el.guid); Group.Group gr = new Group.Group(els, "C245", "Уголок20X4", guids); Mtch match = new Mtch(gr, rule); //6/4/17 TST.Eq(match.ok == OK.Match, true); Log.exit(); }
static RuleConfig() { using (JsonReader jsonReader = new JsonTextReader(new StreamReader("rule.json"))) { JObject jObject = JObject.Load(jsonReader); var jTokens = jObject["Rule"]?.AsJEnumerable(); if (jTokens != null) { var _pageRule = new PageRule(); foreach (var jToken in jTokens) { PageType pageType; if (!Enum.TryParse(jToken?.Value <string>("PageType"), out pageType)) { continue; } Page page = new Page(); var jRules = jToken["Rules"].AsJEnumerable(); foreach (var jRule in jRules) { Rule.Rule rule = new Rule.Rule() { Name = jRule?.Value <string>("Name"), XPath = jRule?.Value <string>("XPath"), Fun = Enum.Parse <Rule.Rule.RuleFun>(jRule?.Value <string>("Fun")), Param = jRule?.Value <string>("Param"), }; page.Add(rule); } _pageRule.AddRule(pageType, page); } pageRule = _pageRule; } } }
void test_Mtch_2() { Log.set(" test_Mtch_2: Rule 15 и Group < B12,5 , 1900x1600 > "); rule = new Rule.Rule(15); ElmAttSet.ElmAttSet elB = new ElmAttSet.ElmAttSet( "ID56A7442F-0000-0D7B-3134-353338303236", "B12,5", "Concrete", "1900x1600", 0, 0, 0, 1000); Dictionary<string, ElmAttSet.ElmAttSet> els = new Dictionary<string, ElmAttSet.ElmAttSet>(); els.Add(elB.guid, elB); List<string> guids = new List<string>(); guids.Add(elB.guid); var model = new Model.Model(); model.setElements(els); model.getGroups(); var gr = model.elmGroups[0]; //6/4/17 TST.Eq(gr.guids.Count, 1); var match = new Mtch(gr, rule); //6/4/17 TST.Eq(match.ok == OK.Match, true); var cmp = match.component; //31/3 TST.Eq(cmp.fps[SType.Material].pars[0].par.ToString(), "b12,5"); Log.exit(); }
bool isMatchGrRule(SType stype, Group.Group gr, Rule.Rule rule) { if (rule == null || !compDP.dpar.ContainsKey(stype)) { return(true); } string sb = new Sec(rule.text, stype).body; if (sb == "") { return(true); } var ruleSyns = rule.synonyms; string comMatPrf = viewComp_(stype); string grMatPrf = stype == SType.Material ? gr.mat : gr.prf; if (ruleSyns != null && ruleSyns.ContainsKey(stype)) { List <string> Syns = ruleSyns[stype].ToList(); if (!Lib.IContains(Syns, comMatPrf) || !Lib.IContains(Syns, grMatPrf)) { return(false); } string c = strExclude(comMatPrf, Syns); string g = strExclude(grMatPrf, Syns); if (c == g) { return(true); } string pattern = new Sec(rule.text, stype).body.Replace("=", ""); foreach (var s in Syns) { pattern = strExclude(pattern, Syns); } return(isOK(pattern, c, g)); } return(comMatPrf == grMatPrf); }
/// <summary> /// Mtch(gr, _rule) - check if Group gr is in match with rule /// if Mtch.ok.Match - return Mtch.Component chousen from CompSet.Component /// else ok.NoMatch /// </summary> /// <param name="gr"></param> /// <param name="_rule"></param> public Mtch(Group.Group gr, Rule.Rule _rule) { if (gr == null || gr.guids == null || gr.guids.Count < 1) Msg.F("Matcher__Mtch Bad arguments"); ok = OK.NoMatch; group = gr; foreach (var comp in _rule.CompSet.Components) { bool found = false; try { found = comp.isMatch(gr, _rule); } catch { } if (!found) continue; //-- Component is found - fill Price for all Guids elemets ok = OK.Match; string priceStr; try { priceStr = comp.Str(SType.Price); } catch { Msg.F("Match: Bad Price descriptor", _rule.sSupl, _rule.sCS); } component = comp; //29/8 gr.match = this; //27/3!! rule = _rule; gr.totalPrice = getPrice(gr, rule.CompSet.csDP, comp.Str(SType.Price)); break; } }
public void UT_CompSet_init_Naive() { boot.Init(); Mod mod = new Mod(); // test 0: бетон -> должен быть DP[UNIT_Vol] Supl spl = new Supl("ГК Монолит СПб"); CompSet csb = new CompSet("Товарный бетон", spl); Assert.IsNotNull(csb); Assert.IsNotNull(csb.csDP); Assert.AreEqual(4, csb.csDP.dpStr.Count); Assert.IsTrue(csb.csDP.dpar.ContainsKey(SType.UNIT_Vol)); // test 1: after bug "Ед: руб/т" не попадал в compDP -> compDP содержит SType.UNIT_Weight Supl supl = new Supl("ЛенСпецСталь"); CompSet cs = new CompSet("Полоса", supl); Assert.IsTrue(cs.csDP.dpar.ContainsKey(SType.UNIT_Weight)); // test 2: Check if all Rules have CompSet with Section Unit_ mod = mod.sr.SetModel(boot, initSupl: true); Assert.IsTrue(mod.Rules.Count > 0); Rule.Rule r = mod.Rules.ToList()[3]; foreach (var rule in mod.Rules) { var csDP = rule.CompSet.csDP; bool bw = csDP.dpStr.ContainsKey(SType.UNIT_Weight); bool bv = csDP.dpStr.ContainsKey(SType.UNIT_Vol); Assert.IsTrue(bw || bv); } FileOp.AppQuit(); }
////////////////public FingerPrint(Sec.SType stype, string str, ParType parType = ParType.String) ////////////////{ // 21/3 //////// Param par = new Param(str, parType); //////////////// pars.Add(par); ////////////////} public FingerPrint(string str, Rule.Rule rule, Sec sec) { FingerPrint ruleFP = rule.ruleFPs[sec.type]; // FingerPrint csFP = rule.CompSet.csFPs.Find(x => x.section.type == sec.type); SType stype = sec.type; var vv = rule.CompSet.csFPs; //20/3 ЗАГЛУШКА!! FingerPrint csFP = rule.CompSet.csFPs[stype]; section = sec; string ruleText = sec.body; List<string> sPars = ReverseFomat(str, ruleText); int i = 0; foreach(var p in sPars) { //20/3 ЗАГЛУШКА!! Parameter.Parameter csPar = (Parameter.Parameter)csFP.pars[i++]; //20/3 ЗАГЛУШКА!! Parameter.Parameter par = new Parameter.Parameter(str, csPar.ptype); //20/3 ЗАГЛУШКА!! pars.Add(par); } // str = Section.body в строке прайс-листа // template - Section.body в Rule.text // заполняет pars в FP для Component //12/3 foreach (var par in ReverseFormat(str, ruleText)) pars.Add(par); }
public void UT_comp_PL_Native() { boot.Init(); // test 1 Native: берем группу, правила и компонент - пластину PL8 из модели model = model.sr.SetModel(boot); if (model.name != "Chasovnya+lepestok") goto exit; gr = model.elmGroups[23]; Assert.AreEqual("—8", gr.prf); rule = new Rule.Rule(6); Assert.AreEqual(58, rule.text.Length); rule.Init(); Assert.AreEqual(93, rule.CompSet.Components.Count); comp = rule.CompSet.Components[60]; Assert.AreEqual("С245", comp.Str(SType.Material)); Assert.AreEqual("PL8x100", comp.Str(SType.Profile)); bool b = comp.isMatch(gr, rule); Assert.IsTrue(b); //test 2 Native: обрабатываем все группы, но проверяем только нужную - PL8 Mtch _mtch = null; foreach (var g in model.elmGroups) { _mtch = new Mtch(g, rule); if (g.prf != "—8") continue; Assert.AreEqual(Mtch.OK.Match, _mtch.ok); } //test 3 Native: загружаем несколько Правил model.Rules.Clear(); rule = new Rule.Rule(5); rule.Init(); model.Rules.Add(rule); rule = new Rule.Rule(6); rule.Init(); model.Rules.Add(rule); _mtch = null; Mtch found_mtch = null; foreach (var g in model.elmGroups) { foreach (var r in model.Rules) { _mtch = new Mtch(g, r); if (g.prf != "—8" || !r.text.Contains("—")) continue; Assert.AreEqual(Mtch.OK.Match, _mtch.ok); found_mtch = _mtch; break; } } Assert.AreEqual("Полоса", found_mtch.rule.sCS); //test 4 Native with Handle, init all rules model.Rules.Clear(); model.matches.Clear(); Docs rRule = Docs.getDoc("Rules", fatal: false, create_if_notexist: false); for (int i = 4; i < rRule.il; i++) { rule = new Rule.Rule(i); rule.Init(); model.Rules.Add(rule); } model.mh.Hndl(ref model); foreach (var m in model.matches) { if (m.group.prf != "—8") continue; Assert.AreEqual(Mtch.OK.Match, m.ok); Assert.AreEqual("Полоса", m.rule.sCS); Assert.AreEqual("СтальХолдинг", m.rule.sSupl); } //test 5 Native with Pricing model.Rules.Clear(); model.matches.Clear(); model.mh.Pricing(ref model); if (model.name != "Chasovnya+lepestok") goto exit; bool c235found = false; //проверим, что это в самом деле правила из TSmatchINFO/Rules - есть С235 foreach (var r in model.Rules) { if (!r.text.Contains("235")) continue; c235found = true; break; } Assert.IsTrue(c235found); //полоса PL8 находится в matches[23] Mtch found_match = model.matches[23]; Assert.AreEqual(Mtch.OK.Match, found_match.ok); Assert.AreEqual("Полоса", found_match.rule.sCS); Assert.AreEqual("СтальХолдинг", found_match.rule.sSupl); exit: FileOp.AppQuit(); }