analytable.go 92 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249
  1. package pretreated
  2. import (
  3. "fmt"
  4. u "jy/util"
  5. qutil "qfw/util"
  6. "regexp"
  7. "strings"
  8. "github.com/PuerkitoBio/goquery"
  9. )
  10. /**
  11. 全局变量,主要是一堆判断正则
  12. **/
  13. var (
  14. //清理品目中数字
  15. numclear = regexp.MustCompile("^[\\d一二三四五六七八九十.]+")
  16. //清理表格title中的不需要的内容
  17. tabletitleclear = regexp.MustCompile("[\\s\u3000\u2003\u00a0\\n、.,.。、_/((人民币万元件个公斤))]")
  18. //清理表格中是key中包含的空格或数字等
  19. tablekeyclear = regexp.MustCompile("[\\s\u3000\u2003\u00a0\\n、.,.。、_/]+|^[\\d一二三四五六七八九十]+[、.]*|[((【\\[].*?[))】\\]]")
  20. //清理表格td中的符号
  21. tabletdclear = regexp.MustCompile("[\\s\u3000\u2003\u00a0\\n、,。、_??;;~\\-#\\\\()(){}【】\\[\\]<>《》{}〔〕¥$]*")
  22. //判断key是金额,对万元的处理
  23. moneyreg = regexp.MustCompile("(预算|费|价|额|规模|投资)")
  24. //根据表格的内容判断是不是表头,如果含有金额则不是表头
  25. MoneyReg = regexp.MustCompile("^[\\s  ::0-9.万元()()人民币¥$]+$")
  26. //判断分包时
  27. moneyNum = regexp.MustCompile("[元整¥万]")
  28. //对隐藏表格的判断
  29. display = regexp.MustCompile("(?i).*?display\\s?[:]\\s?none.*")
  30. //---------------
  31. //求是分包的概率
  32. //根据表格的标签对分包进行打分
  33. TableMultiPackageReg_4 = regexp.MustCompile("(标段|分包|包段|划分|子包|标包|合同段)")
  34. TableMultiPackageReg_2 = regexp.MustCompile("(概况|范围|情况|内容|详细|结果|信息)")
  35. //在判断分包打分前过虑表格key
  36. FilterKey_2 = regexp.MustCompile("招标|投标|项目")
  37. //根据表格的key进行分包打分
  38. FindKey_2 = regexp.MustCompile("([分子][包标](号)?|标[号项段包](划分)?|包件?[号段名数])")
  39. //对值进行分包判断
  40. FindVal_1 = regexp.MustCompile("[第]?([一二三四五六七八九十0-9A-Za-zⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫ]+)((子|合同|分|施工|监理)?(标段?|包|合同段|标包))|((子|合同|分|施工|监理)?(标|包)(段|号)?)[  \u3000\u2003\u00a0]*([一二三四五六七八九十0-9A-Za-zⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫ]+)")
  41. FindVal2_1 = regexp.MustCompile("([一二三四五六七八九十0-9A-Za-zⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫ\\-]+)|^(设计|施工|监理|验收)[分子]?[标包]?[段号]?$")
  42. //判断分包前排除
  43. excludeKey = regexp.MustCompile("(涉及包号|包件号?|项目标号|规格|型号|招标范围|业绩|废标)|(^编号$)|([^包段标]编号)") //编号|划分
  44. //-------------
  45. cut = u.NewCut()
  46. //清理表格标签正则
  47. ClearTagReg = regexp.MustCompile("<[^>]*?>|[\\s\\n\\r]*$")
  48. //查找表格标签正则
  49. ttagreg = regexp.MustCompile("(?s)([^\\n::。,;\\s\u3000\u2003\u00a0]{2,30})[::]?[^::。;!\\n]{0,35}[\\s\\n]*$")
  50. //判断表格是表头的概率
  51. checkval = float32(0.6)
  52. //tdval_reg = regexp.MustCompile(`([\p{Han}][\p{Han}\s、()\\(\\)]{1,9})[::]([^::\\n。]{5,60})(?:[;;,,.。\\n\\t\\s])?`)
  53. //空格替换
  54. repSpace = regexp.MustCompile("[\\s\u3000\u2003\u00a0::]+|\\\\t+")
  55. //对表格kv的处理
  56. //对不能标准化的key做批识
  57. filter_tag_zb = regexp.MustCompile("(中标|成交|投标)[\\p{Han}]{0,6}(情况|结果|信息|明细)")
  58. //中标金额
  59. //包含以下字眼做标准化处理
  60. filter_zbje_k = regexp.MustCompile("(中标|成交|总|拦标|合同|供[应货]商|报)[\\p{Han}、]{0,6}(价|额|[大小]写|[万亿]?元).{0,4}$")
  61. //简单判断金额
  62. filter_zbje_jd = regexp.MustCompile("^[^售]{0,4}(价|额).{0,4}$")
  63. //且排队以下字眼的key
  64. filter_zbje_kn = regexp.MustCompile("得分|打分|时间|业绩|须知|分$")
  65. //且值包含以下字眼
  66. filter_zbje_v = regexp.MustCompile("[¥$$0-9一二三四五六七八九十,,〇零点..壹贰叁肆伍陆柒捌玖拾百佰千仟万亿億元圆角分整正()::大小写]{2,16}")
  67. //中标单位的处理
  68. //包含以下字眼的Key标准化
  69. filter_zbdw_ky = regexp.MustCompile("(中标|成交|拦标|合同|选中|投标|拟|预|最终)[\\p{Han}、]{0,6}(供[应货]商|企业|单位|人|机构)(名称)?.{0,4}$")
  70. //简单判断
  71. filter_zbdw_jd = regexp.MustCompile("(投标|成交|中标|合同)(供应商|单位|人|名称).{0,4}$")
  72. //且不包含以下字眼
  73. filter_zbdw_kn = regexp.MustCompile("第[2二3三4四5五]|得分|地址")
  74. //且值包含以下字眼
  75. filter_zbdw_v = regexp.MustCompile("(公司|集团|研究院|设计院|局|厂|部|站|城|店|市|所|处)$|([^购]中心|办公|用品)")
  76. //且值包含以下字眼
  77. filter_zbdw_v2 = regexp.MustCompile("(公司|集团|研究院|设计院|局|厂|部|站|城|店|市|所|处)$")
  78. //Tg = map[string]interface{}{}
  79. //一些表格没有表头,是空的,对值是排序的做处理对应 NullTxBid
  80. NullTdReg = regexp.MustCompile("(首选|第[一二三四五1-5])(中标|成交)?(名|(候选|排序)?(人|单位|供应商))")
  81. NullTxtBid = "成交供应商排名"
  82. projectnameReg = regexp.MustCompile("((公开)?招标)*[((第]*[一二三四五六七八九十a-zA-Z0-9]+(标段|包|标|段)[))]*$")
  83. MhSpilt = regexp.MustCompile("[::]")
  84. //识别采购单位联系人、联系电话、代理机构联系人、联系电话
  85. ContactInfoVagueReg = regexp.MustCompile("邮政编码|邮编|(征求意见|报名审核购买)?((联系人?|办公)?((电话([//]传真)?|手机)(号码)?|邮箱(地址)?|(地(址|点)))|(联系|收料)(人(姓名)?|方式)|传真|电子邮件|(主要负责|项目(负责|联系)|(项目)?经办)人)|采购方代表")
  86. ContactInfoMustReg = regexp.MustCompile("^(" + ContactInfoVagueReg.String() + ")$")
  87. ContactType = map[string]*regexp.Regexp{
  88. "采购单位": regexp.MustCompile("(采购(项目.{2}|服务)?|比选|询价|发布人?|甲|招标(服务)?|建设|委托|发包|业主|使用|谈判|本招标项目经办|征求意见联系|项目实施)(人|单位|部门|机构|机关|(执行)?方)|(项目|建(库|设))单位|招标人信息|采购中心地址|业主|收料人"),
  89. "代理机构": regexp.MustCompile("(代理|受托).{0,2}(人|方|单位|公司|机构)|招标机构|采购代理"),
  90. }
  91. ContactBuyerPersonFilterReg = regexp.MustCompile("(管理局)$")
  92. MultipleValueSplitReg = regexp.MustCompile("[,,、\\s\u3000\u2003\u00a0]")
  93. BuyerContacts = []string{"采购单位联系人", "采购单位联系电话", "采购单位联系地址"}
  94. FilterSerial = regexp.MustCompile(".+[、..::,]")
  95. filterTableWror = regexp.MustCompile("班子成员")
  96. underline = regexp.MustCompile("_+$")
  97. )
  98. //在解析时,判断表格元素是否隐藏
  99. func IsHide(g *goquery.Selection) (b bool) {
  100. style, exists := g.Attr("style")
  101. if exists {
  102. b = display.MatchString(style)
  103. }
  104. return
  105. }
  106. //对表格的key进行标准化处理,多个k相同时,出现覆盖问题
  107. //待扩展,暂不支持正则标签库
  108. func CommonDataAnaly(k, tabletag, tabledesc string, v interface{}) (k1 []string, weight []int, v1, returntag string, b bool) {
  109. k1 = []string{}
  110. weight = []int{}
  111. tk := k
  112. if sv, sok := v.(string); sok { //取KV
  113. v1 = sv
  114. } else if sv, sok := v.([]string); sok { //是数组先默认取第一个
  115. v1 = sv[0]
  116. }
  117. //对值单位的处理
  118. if moneyreg.MatchString(tk) {
  119. v1 += GetMoneyUnit(tk, v1)
  120. }
  121. //先清理key
  122. //u.Debug(1, k, v1)
  123. k = ClearKey(k, 2)
  124. //u.Debug(2, k)
  125. //取标准key
  126. res := u.GetTags(k)
  127. if len(res) == 0 && tk != k {
  128. res = u.GetTags(tk)
  129. }
  130. //log.Println(k, res)
  131. // if len(res) == 0 {
  132. // go u.AddtoNoMatchMap(tk)
  133. // }
  134. //当取到标准化值时,放入数组
  135. if len(res) > 0 {
  136. b = true
  137. for _, t1 := range res {
  138. k1 = append(k1, t1.Value)
  139. weight = append(weight, t1.Weight)
  140. }
  141. //k1 = res[0].Value
  142. }
  143. //没有取到标准化key时,对中标金额和中标单位的逻辑处理
  144. if !b {
  145. if filter_zbje_k.MatchString(k) && !filter_zbje_kn.MatchString(k) && filter_zbje_v.MatchString(v1) {
  146. if tabletag == "" {
  147. returntag = "中标情况"
  148. }
  149. k1 = append(k1, "中标金额")
  150. weight = append(weight, -100)
  151. b = true
  152. } else if filter_zbdw_ky.MatchString(k) && !filter_zbdw_kn.MatchString(k) &&
  153. filter_zbdw_v.MatchString(v1) {
  154. k1 = append(k1, "中标单位")
  155. weight = append(weight, -100)
  156. if tabletag == "" {
  157. returntag = "中标情况"
  158. }
  159. b = true
  160. }
  161. }
  162. //对上一步没有取到标准化key的进一步处理
  163. if !b {
  164. if tabletag == "" {
  165. }
  166. if filter_tag_zb.MatchString(tabletag) || filter_tag_zb.MatchString(tabledesc) {
  167. //u.Debug(v1, k, "-----", filter_zbdw_jd.MatchString(k), filter_zbdw_v.MatchString(v1))
  168. if filter_zbje_jd.MatchString(k) && !filter_zbje_kn.MatchString(k) && filter_zbje_v.MatchString(v1) {
  169. k1 = append(k1, "中标金额")
  170. weight = append(weight, -100)
  171. b = true
  172. } /*else if filter_zbdw_jd.MatchString(k) && filter_zbdw_v.MatchString(v1) {
  173. k1 = append(k1, "中标单位")
  174. weight = append(weight, -100)
  175. b = true
  176. }*/
  177. }
  178. }
  179. return
  180. }
  181. //对解析后的表格的kv进行过滤
  182. func (table *Table) KVFilter() {
  183. //1.标准化值查找
  184. //2.对数组的处理
  185. //3.对分包的处理
  186. //4.对KV的处理
  187. //判断表格是否有用,调用abandontable正则数组进行判断
  188. //遍历每一行
  189. for _, tr := range table.TRs {
  190. for _, td := range tr.TDs {
  191. //fmt.Println(td.BH, td.MustBH, td.Val, td.SortKV.Map)
  192. bc := false
  193. if !td.BH {
  194. //表头是否是无用内容
  195. if td.HeadTd != nil {
  196. bc, _, _, _, _ = CheckCommon(td.HeadTd.Val, "abandontable")
  197. }
  198. }
  199. if !bc {
  200. //td元素有内嵌kv,遍历放入table的Kv中
  201. if len(td.SortKV.Keys) > 0 {
  202. for _, k3 := range td.SortKV.Keys {
  203. _val := td.SortKV.Map[k3]
  204. //thisFlag := false
  205. if td.HeadTd != nil && len([]rune(k3)) < 4 {
  206. k3 = td.HeadTd.Val + k3
  207. }
  208. if table.SortKV.Map[k3] == nil {
  209. //u.Debug(k3, _val)
  210. //if !thisFlag || (thisFlag && table.SortKV.Map[k3] == nil) {
  211. table.SortKV.AddKey(k3, _val)
  212. }
  213. }
  214. }
  215. }
  216. //td有子表格的处理
  217. //u.Debug(td.BH, td.Val, td.SonTableResult)
  218. if td.SonTableResult != nil {
  219. //u.Debug(td.SonTableResult.SortKV.Map, "-------", td.SonTableResult.Tabs)
  220. for _, k3 := range td.SonTableResult.SortKV.Keys {
  221. if table.StandKV[k3] == "" || td.SonTableResult.SortKVWeight[k3] > table.StandKVWeight[k3] {
  222. table.StandKV[k3] = qutil.ObjToString(td.SonTableResult.SortKV.Map[k3])
  223. table.StandKVWeight[k3] = td.SonTableResult.SortKVWeight[k3]
  224. }
  225. }
  226. //中标候选人排序
  227. if table.WinnerOrder == nil || len(table.WinnerOrder) == 0 {
  228. table.WinnerOrder = td.SonTableResult.WinnerOrder
  229. } else {
  230. winnerOrderEntity.Merge(table.WinnerOrder, td.SonTableResult.WinnerOrder)
  231. }
  232. }
  233. }
  234. }
  235. as := NewSortMap()
  236. //表格描述处理,对成交结果的处理
  237. for _, k := range table.SortKV.Keys {
  238. if regexp.MustCompile("(成交|中标|候选|排名|名次|供应商排序)").MatchString(k) {
  239. table.Desc += "成交结果,"
  240. }
  241. }
  242. //遍历table.sortkv,进行过滤处理,并放入标准化KV中,如果值是数组跳到下一步处理
  243. for _, k := range table.SortKV.Keys {
  244. if regexp.MustCompile("^单价").MatchString(k) {
  245. continue
  246. }
  247. v := table.SortKV.Map[k]
  248. //u.Debug(k, v)
  249. if _, ok := v.(string); ok {
  250. k = regSpliteSegment.ReplaceAllString(regReplAllSpace.ReplaceAllString(k, ""), "")
  251. k1, w1, v1, tag, b := CommonDataAnaly(k, table.Tag, table.Desc, v)
  252. //u.Debug(k, v, k1, w1, v1, tag, b)
  253. if b {
  254. //降低冒号值的权重
  255. if MhSpilt.MatchString(v1) {
  256. for pos, _ := range k1 {
  257. w1[pos] -= 50
  258. }
  259. }
  260. if tag != "" && table.Tag == "" {
  261. table.Tag = tag
  262. }
  263. for pos, k2 := range k1 {
  264. if table.StandKV[k2] == "" || w1[pos] > table.StandKVWeight[k2] {
  265. table.StandKV[k2] = v1 //本节点
  266. table.StandKVWeight[k2] = w1[pos]
  267. }
  268. // else if k2 == "中标金额" {
  269. // // u.Debug(qutil.Float64All(v1), qutil.Float64All(table.StandKV[k2]))
  270. // if qutil.Float64All(v1) > qutil.Float64All(table.StandKV[k2]) {
  271. // table.StandKV[k2] = v1
  272. // }
  273. // }
  274. }
  275. }
  276. } else {
  277. //u.Debug(k, v, "---------")
  278. as.AddKey(k, v)
  279. }
  280. }
  281. //处理值是数组的kv放入标准化kv中
  282. checkKey := map[int]bool{}
  283. for kn, k := range as.Keys {
  284. v := as.Map[k]
  285. if vm, ok := v.([]map[string]interface{}); ok && k == NullTxtBid {
  286. if table.WinnerOrder == nil {
  287. table.WinnerOrder = []map[string]interface{}{}
  288. }
  289. table.WinnerOrder = append(table.WinnerOrder, vm...)
  290. } else {
  291. //增加候选人排序逻辑
  292. if table.WinnerOrder == nil && !checkKey[kn] {
  293. if vs1, ok := v.([]string); ok {
  294. smap := make([]map[string]interface{}, len(vs1))
  295. for n1, _ := range vs1 {
  296. smap[n1] = map[string]interface{}{}
  297. }
  298. for kn1, k := range as.Keys[kn:] {
  299. v := as.Map[k]
  300. if ContactType["采购单位"].MatchString(k) || ContactType["代理机构"].MatchString(k) {
  301. continue
  302. }
  303. if vs, ok := v.([]string); ok && len(vs) == len(vs1) {
  304. res, _, _, _, repl := CheckCommon(k, "bidorder")
  305. kv := ""
  306. if !res {
  307. kt := u.GetTags(filterThText.ReplaceAllString(ClearKey(k, 2), ""))
  308. if kt.Len() > 0 {
  309. kv = kt[0].Value
  310. }
  311. }
  312. if res || kv != "" { //连续往下找几个key
  313. checkKey[kn+kn1] = true
  314. if repl == "sort" {
  315. for vsk, vsv := range vs {
  316. smap[vsk]["sortstr"] = vsv
  317. smap[vsk]["sort"] = GetBidSort(vsv, vsk+1)
  318. }
  319. } else if repl == "entname" || kv == "中标单位" {
  320. for vsk, vsv := range vs {
  321. smap[vsk]["entname"] = winnerOrderEntity.clear("中标单位", vsv)
  322. }
  323. } else if kv == "中标金额" {
  324. for vsk, vsv := range vs {
  325. p1 := qutil.Float64All(smap[vsk]["price"])
  326. p2 := qutil.Float64All(vsv)
  327. if p2 > p1 {
  328. smap[vsk]["price"] = winnerOrderEntity.clear("中标金额", vsv+GetMoneyUnit(k, vsv))
  329. }
  330. }
  331. }
  332. }
  333. } else {
  334. //break
  335. }
  336. }
  337. newSmap := []map[string]interface{}{}
  338. for _, smap_v := range smap {
  339. if len(smap_v) > 0 {
  340. newSmap = append(newSmap, smap_v)
  341. }
  342. }
  343. if len(newSmap) > 0 {
  344. table.WinnerOrder = newSmap
  345. }
  346. }
  347. }
  348. k1, w1, v1, tag, b := CommonDataAnaly(k, table.Tag, table.Desc, v)
  349. if b {
  350. if tag != "" && table.Tag == "" {
  351. table.Tag = tag
  352. }
  353. for pos, k2 := range k1 {
  354. if table.StandKV[k2] == "" || w1[pos] > table.StandKVWeight[k2] {
  355. table.StandKV[k2] = v1 //本节点
  356. table.StandKVWeight[k2] = w1[pos]
  357. }
  358. // else if k2 == "中标金额" {
  359. // if qutil.Float64All(v1) > qutil.Float64All(table.StandKV[k2]) {
  360. // table.StandKV[k2] = v1
  361. // }
  362. // }
  363. }
  364. }
  365. }
  366. }
  367. //
  368. if filterTableWror.MatchString(table.Tag) {
  369. table.WinnerOrder = nil
  370. }
  371. //
  372. if len(table.WinnerOrder) > 0 || !table.BPackage {
  373. winnerOrder := []map[string]interface{}{}
  374. maxSort := 0
  375. //调整顺序
  376. for i := 0; i < 2; i++ {
  377. for _, v := range table.WinnerOrder {
  378. sortstr, _ := v["sortstr"].(string)
  379. if (i == 0 && sortstr == "") || (i == 1 && sortstr != "") {
  380. continue
  381. }
  382. sort, _ := v["sort"].(int)
  383. if i == 0 {
  384. if maxSort == 0 || sort > maxSort {
  385. maxSort = sort
  386. }
  387. } else {
  388. maxSort++
  389. v["sort"] = maxSort
  390. }
  391. winnerOrder = append(winnerOrder, v)
  392. }
  393. if len(winnerOrder) == len(table.WinnerOrder) {
  394. break
  395. }
  396. }
  397. table.WinnerOrder = winnerOrder
  398. winnerOrder = []map[string]interface{}{}
  399. L:
  400. for _, tr := range table.TRs {
  401. for _, td := range tr.TDs {
  402. winnerOrder = winnerOrderEntity.Find(td.Val, true, 3)
  403. if len(winnerOrder) > 0 {
  404. break L
  405. }
  406. }
  407. }
  408. if len(table.WinnerOrder) > 0 {
  409. //中标候选人合并
  410. winnerOrderEntity.Merge(table.WinnerOrder, winnerOrder)
  411. if table.StandKV["中标单位"] == "" {
  412. ent := table.WinnerOrder[0]["entname"]
  413. if ent != nil {
  414. table.StandKV["中标单位"], _ = ent.(string)
  415. table.StandKVWeight["中标单位"] = -25
  416. }
  417. }
  418. } else if !table.BPackage {
  419. if len(winnerOrder) > 1 {
  420. table.WinnerOrder = winnerOrder
  421. }
  422. }
  423. }
  424. //对中标候选人进行排序
  425. winnerOrderEntity.Order(table.WinnerOrder)
  426. //该表格有一个分包,并且有中标候选人排序的情况下,把中标候选人放到包里面
  427. if table.BlockPackage != nil && table.BlockPackage.Keys != nil && len(table.BlockPackage.Keys) == 1 {
  428. if table.BlockPackage.Map != nil {
  429. onePkgKey := table.BlockPackage.Keys[0]
  430. onePkg, _ := table.BlockPackage.Map[onePkgKey].(*u.BlockPackage)
  431. if onePkg != nil && onePkg.WinnerOrder != nil && len(onePkg.WinnerOrder) == 0 {
  432. onePkg.WinnerOrder = table.WinnerOrder
  433. table.BlockPackage.Map[onePkgKey] = onePkg
  434. }
  435. }
  436. }
  437. }
  438. //表格结果合并到父表格集中
  439. func (table *Table) MergerToTableresult() {
  440. //对多包表格的多包值的合并处理
  441. if table.BPackage {
  442. table.TableResult.IsMultiPackage = true
  443. for k, v := range table.BlockPackage.Map {
  444. package1 := table.TableResult.PackageMap.Map[k]
  445. if package1 == nil {
  446. table.TableResult.PackageMap.AddKey(k, v)
  447. } else {
  448. bp := package1.(*u.BlockPackage)
  449. if bp.TableKV == nil {
  450. bp.TableKV = u.NewJobKv()
  451. }
  452. v1 := v.(*u.BlockPackage)
  453. if v1.TableKV != nil && v1.TableKV.Kv != nil {
  454. for k2, v2 := range v1.TableKV.Kv {
  455. if bp.TableKV == nil {
  456. bp.TableKV = u.NewJobKv()
  457. }
  458. if bp.TableKV.Kv[k2] == "" || (v1.TableKV.KvTag[k2] != nil && bp.TableKV.KvTag[k2] != nil && v1.TableKV.KvTag[k2].Weight > bp.TableKV.KvTag[k2].Weight) {
  459. //可能会报错 assignment to entry in nil map
  460. bp.TableKV.Kv[k2] = v2
  461. bp.Text += fmt.Sprintf("%v:%v\n", k2, v2)
  462. }
  463. }
  464. }
  465. bp.WinnerOrder = v1.WinnerOrder
  466. //table.TableResult.PackageMap.AddKey(k, v)
  467. }
  468. }
  469. // str := ""
  470. // for _, k := range table.TableResult.PackageMap.Keys {
  471. // v := table.TableResult.PackageMap.Map[k].(*u.BlockPackage)
  472. // str += fmt.Sprintf("包号:%s,中标人:%s,中标价:%s,预算:%s,文本:%s,排名:%v ---\t", v.Index, v.TableKV["中标单位"]+v.ColonKV["中标单位"], v.TableKV["中标金额"]+v.ColonKV["中标金额"], v.TableKV["预算"]+v.ColonKV["预算"], v.Text, v.WinnerOrder)
  473. // }
  474. // u.Debug(table, table.TableResult, str)
  475. }
  476. //遍历标准key到tableresult.sortkv中
  477. for k, v := range table.StandKV {
  478. if table.TableResult.SortKV.Map[k] == nil || table.StandKVWeight[k] > table.TableResult.SortKVWeight[k] || strings.Contains(table.Tag, "变更") {
  479. v = strings.Replace(v, "__", "", -1)
  480. if table.TableResult.SortKV.Map[k] == nil {
  481. table.TableResult.SortKV.AddKey(k, v) //父集
  482. } else {
  483. table.TableResult.SortKV.ReplaceKey(k, v, k)
  484. }
  485. table.TableResult.SortKVWeight[k] = table.StandKVWeight[k]
  486. } else if table.TableResult.SortKV.Map[k] != nil {
  487. //u.Debug(k, v, table.TableResult.SortKV.Map[k], "..............")
  488. }
  489. }
  490. //表格的块标签
  491. if table.TableResult.BlockTag == "" && table.Tag != "" {
  492. table.TableResult.BlockTag = table.Tag
  493. }
  494. if table.TableResult.WinnerOrder == nil || len(table.TableResult.WinnerOrder) == 0 {
  495. table.TableResult.WinnerOrder = table.WinnerOrder
  496. }
  497. //增加brand 并列table
  498. if len(table.BrandData) > 0 {
  499. for _, v := range table.BrandData {
  500. if len(v) > 0 {
  501. table.TableResult.BrandData = append(table.TableResult.BrandData, v)
  502. }
  503. }
  504. }
  505. }
  506. /**
  507. 解析表格入口
  508. 返回:汇总表格对象
  509. **/
  510. func AnalyTableV2(tabs []*goquery.Selection, toptype, blockTag, con string, itype int, _id interface{}) (tabres *TableResult) {
  511. defer qutil.Catch()
  512. //u.Debug(con)
  513. if itype == 1 {
  514. //修复表格
  515. con = RepairCon(con)
  516. }
  517. //生成tableresult对象
  518. tabres = NewTableResult(_id, toptype, blockTag, con, itype)
  519. //可以有多个table
  520. for _, table := range tabs {
  521. //隐藏表格跳过
  522. if IsHide(table) {
  523. continue
  524. }
  525. tabres.GoqueryTabs = append(tabres.GoqueryTabs, table)
  526. }
  527. //解析表格集
  528. tabres.Analy()
  529. return
  530. }
  531. //开始解析表格集
  532. func (ts *TableResult) Analy() {
  533. tabs := []*Table{}
  534. contactFormat := &u.ContactFormat{
  535. IndexMap: map[int]string{},
  536. MatchMap: map[string]map[string]bool{},
  537. }
  538. for _, table := range ts.GoqueryTabs {
  539. tn := NewTable(ts.Html, ts, table)
  540. //核心模块
  541. ts := tn.Analy(contactFormat)
  542. for _, tab := range ts {
  543. tabs = append(tabs, tab)
  544. //fmt.Println("tab.SortKV.Map", tab.SortKV.Keys)
  545. }
  546. //tn.SonTables = append(tn.SonTables, tn)
  547. }
  548. //统一合并,考虑统一多表格是多包的情况---新增
  549. if len(tabs) > 1 {
  550. pns := map[string]string{}
  551. pnarr := []string{}
  552. for _, table := range tabs {
  553. pn := table.StandKV["项目名称"]
  554. if pn != "" && TitleReg.MatchString(pn) {
  555. pnarr = append(pnarr, pn)
  556. matchres := TitleReg.FindAllStringSubmatch(pn, -1)
  557. if len(matchres) == 1 && len(matchres[0]) > 0 {
  558. v1 := u.PackageNumberConvert(matchres[0][0])
  559. pns[v1] = matchres[0][0]
  560. bp := &u.BlockPackage{}
  561. bp.Index = v1
  562. bp.Origin = matchres[0][0]
  563. bp.TableKV = u.NewJobKv()
  564. for _, k := range []string{"中标金额", "中标单位", "预算", "成交状态", "项目名称", "项目编号", "采购范围"} {
  565. bp.TableKV.Kv[k] = table.StandKV[k]
  566. }
  567. bp.WinnerOrder = table.WinnerOrder
  568. if table.BlockPackage.Map[v1] == nil {
  569. table.BPackage = true
  570. table.BlockPackage.AddKey(v1, bp)
  571. }
  572. }
  573. }
  574. }
  575. if len(tabs) == len(pns) {
  576. //多个表格,每个表格都是一个分包 http://www.cxzwfw.gov.cn/info/1009/6963.htm
  577. //项目名称、项目编号、采购单位、招标机构、预算
  578. pname := projectnameReg.ReplaceAllString(pnarr[0], "")
  579. btrue := true
  580. for _, pn := range pnarr[1:] {
  581. pn = projectnameReg.ReplaceAllString(pn, "")
  582. //u.Debug(pn, pname)
  583. if pn != pname {
  584. //项目名称不一致
  585. btrue = false
  586. break
  587. }
  588. }
  589. if btrue {
  590. ts.SortKV.AddKey("项目名称", pname)
  591. ts.SortKVWeight["项目名称"] = 100
  592. for _, table := range tabs {
  593. table.BPackage = true
  594. //预算、中标金额、NullTxtBid成交供应商排名 中标单位 成交状态
  595. if table.BlockPackage != nil && len(table.BlockPackage.Keys) == 1 {
  596. bp := table.BlockPackage.Map[table.BlockPackage.Keys[0]].(*u.BlockPackage)
  597. if table.TableResult.WinnerOrder != nil {
  598. bp.WinnerOrder = table.WinnerOrder
  599. }
  600. if bp != nil && table.StandKV != nil {
  601. if bp.TableKV == nil {
  602. bp.TableKV = u.NewJobKv()
  603. }
  604. for nk, k := range []string{"中标金额", "中标单位", "预算", "成交状态", "项目名称", "项目编号", "采购范围"} {
  605. bp.TableKV.Kv[k] = table.StandKV[k]
  606. if nk < 4 {
  607. delete(table.StandKV, k)
  608. }
  609. }
  610. }
  611. }
  612. }
  613. }
  614. }
  615. }
  616. for _, table := range tabs {
  617. table.MergerToTableresult()
  618. // for k, v := range table.TableResult.SortKV.Map {
  619. // log.Println(k, v)
  620. // }
  621. }
  622. }
  623. //解析表格
  624. func (table *Table) Analy(contactFormat *u.ContactFormat) []*Table {
  625. //查找表体中的tr对象
  626. trs := table.Goquery.ChildrenFiltered("tbody,thead,tfoot").ChildrenFiltered("tr")
  627. if trs.Size() == 0 {
  628. trs = table.Goquery.ChildrenFiltered("tr")
  629. }
  630. //num := 0
  631. //遍历tr数组
  632. trs.Each(func(n int, sel *goquery.Selection) {
  633. //隐藏行不处理
  634. if IsHide(sel) {
  635. return
  636. }
  637. //遍历每行的td
  638. tds := sel.ChildrenFiltered("td,th")
  639. TR := NewTR(table)
  640. tdTextIsNull := true
  641. tds.Each(func(m int, selm *goquery.Selection) {
  642. //对隐藏列不处理!!!
  643. if IsHide(selm) {
  644. return
  645. }
  646. //进入每一个单元格
  647. td := NewTD(selm, TR, table)
  648. //num++
  649. TR.AddTD(td)
  650. if td.Val != "" { //删除一个tr,tr中所有td是空值的
  651. tdTextIsNull = false
  652. }
  653. })
  654. //tr中所有td的内容为空 将tr删除
  655. if !tdTextIsNull {
  656. table.AddTR(TR)
  657. }
  658. })
  659. //重置行列
  660. table.ComputeRowColSpan()
  661. // for n, tr := range table.TRs {
  662. // for m, td := range tr.TDs {
  663. // qutil.Debug(td.BH, n, m, td.Text, td.StartRow, td.EndRow, td.StartCol, td.EndCol)
  664. // }
  665. // }
  666. tm := []map[string]interface{}{}
  667. tmk := map[string]bool{}
  668. tmn := map[int]map[string]interface{}{}
  669. for rownum, tr := range table.TRs {
  670. if len(tr.TDs) == 1 && table.ColNum > 1 {
  671. td := tr.TDs[0]
  672. if td.StartCol == 0 && td.EndCol+1 == table.ColNum && len([]rune(td.Val)) > 1 && len([]rune(td.Val)) < 50 {
  673. con, m1, b := CheckMultiPackage(td.Val, "")
  674. if b {
  675. for k, _ := range m1 {
  676. numstr := u.PackageNumberConvert(k)
  677. m2 := map[string]interface{}{
  678. "tag": con,
  679. //"num": numstr,
  680. //"numtxt": v[0],
  681. "startrow": rownum,
  682. }
  683. tmk[numstr] = true
  684. tmn[rownum] = m2
  685. tm = append(tm, m2)
  686. break
  687. }
  688. }
  689. }
  690. }
  691. }
  692. //拆表
  693. ts := []*Table{}
  694. if len(tmk) > 1 && len(tmk) == len(tm) {
  695. var tab1 *Table
  696. for rownum, tr := range table.TRs {
  697. if tab1 == nil {
  698. tab1 = NewTable("", table.TableResult, table.Goquery)
  699. tab1.BSplit = true
  700. if tmn[rownum] != nil {
  701. tab1.StandKV["项目名称"] = tmn[rownum]["tag"].(string)
  702. tab1.StandKVWeight["项目名称"] = -100
  703. }
  704. ts = append(ts, tab1)
  705. }
  706. if tmn[rownum] != nil {
  707. tab1.Tag = tmn[rownum]["tag"].(string)
  708. } else {
  709. tab1.AddTR(tr)
  710. }
  711. if tmn[rownum+1] != nil {
  712. tab1 = nil
  713. }
  714. }
  715. } else {
  716. ts = append(ts, table)
  717. }
  718. for n, table := range ts {
  719. if len(table.TRs) > 0 {
  720. //删除尾部空行
  721. for len(table.TRs) > 0 {
  722. npos := len(table.TRs)
  723. tailTR := table.TRs[npos-1] //最后一个tr
  724. bspace := true
  725. for _, v := range tailTR.TDs {
  726. if v.Val != "" || v.SonTableResult != nil || len(v.SortKV.Keys) > 0 {
  727. bspace = false
  728. break
  729. }
  730. }
  731. if bspace {
  732. table.TRs = table.TRs[:npos-1]
  733. } else {
  734. break
  735. }
  736. }
  737. //table.Print()
  738. //校对表格
  739. table.Adjust()
  740. //查找表格的标签
  741. table.FindTag()
  742. //log.Println(table.TableResult.Id, table.Html)
  743. //分割表格
  744. if table.BSplit {
  745. if !table.BHeader && n > 0 {
  746. for i := n - 1; i > -1; i-- {
  747. if ts[i].BHeader {
  748. if ts[i].BFirstRow {
  749. //取第一行插入到
  750. table.InsertTR(ts[i].TRs[0])
  751. table.Adjust()
  752. }
  753. break
  754. }
  755. }
  756. }
  757. }
  758. //对没有表头表格的处理
  759. _, _, b := CheckMultiPackage(table.Tag, "")
  760. if b {
  761. table.StandKV["项目名称"] = table.Tag
  762. table.StandKVWeight["项目名称"] = -100
  763. }
  764. table.TdContactFormat(contactFormat)
  765. //开始查找kv,核心模块
  766. table.FindKV()
  767. //table中抽取品牌
  768. if u.IsBrandGoods {
  769. table.analyBrand()
  770. }
  771. //判断是否是多包,并处理分包的
  772. table.CheckMultiPackageByTable()
  773. str := "\n"
  774. for k, v := range table.StandKV {
  775. str += fmt.Sprintf("_==___%s:%v\n", k, v)
  776. if table.TableResult.SortKV.Map[k] == nil {
  777. table.TableResult.SortKV.AddKey(k, v)
  778. table.TableResult.SortKVWeight[k] = table.StandKVWeight[k]
  779. }
  780. }
  781. res, _, _, _, _ := CheckCommon(table.Tag, "abandontable")
  782. if !res {
  783. //过滤、标准化、合并kv
  784. table.KVFilter()
  785. }
  786. str = "\n"
  787. for k, v := range table.StandKV {
  788. str += fmt.Sprintf("_____%s:%v\n", k, v)
  789. if table.TableResult.SortKV.Map[k] == nil {
  790. table.TableResult.SortKV.AddKey(k, v)
  791. table.TableResult.SortKVWeight[k] = table.StandKVWeight[k]
  792. }
  793. }
  794. //u.Debug(str)
  795. }
  796. }
  797. return ts
  798. }
  799. func (table *Table) Adjust() {
  800. table.TDNum = func() int {
  801. n := 0
  802. for _, tr := range table.TRs {
  803. n += len(tr.TDs)
  804. }
  805. return n
  806. }()
  807. //有多少行
  808. table.RowNum = len(table.TRs)
  809. // for k1, tr := range table.TRs {
  810. // for k2, td := range tr.TDs {
  811. // qutil.Debug(k1, k2, td.Val, td.Rowspan, td.Colspan, td.ColPos, tr.RowPos)
  812. // }
  813. // }
  814. //计算行列起止位置,跨行跨列处理
  815. table.ComputeRowColSpan()
  816. // for k1, tr := range table.TRs {
  817. // for k2, td := range tr.TDs {
  818. // qutil.Debug(k1, k2, td.Val, td.StartRow, td.EndRow, td.StartCol, td.EndCol)
  819. // }
  820. // }
  821. //大概计算每个起止行列的概率
  822. table.GetKeyRation()
  823. /*
  824. for k, v := range table.StartAndEndRation {
  825. for k1, v1 := range v.Poss {
  826. bs, _ := json.Marshal(v1)
  827. str := ""
  828. for _, td := range v.Tdmap[v1] {
  829. str += "__" + td.Val + fmt.Sprintf("%d_%d_%d_%d", td.StartRow, td.EndRow, td.StartCol, td.EndCol)
  830. }
  831. qutil.Debug(k, k1, string(bs), v.Rationmap[v1], str)
  832. }
  833. }
  834. */
  835. //u.Debug("tdnum:", num, table.RowNum, table.ColNum)
  836. //是否是规则的表格,单元各个数=行数*列数
  837. table.Brule = table.TDNum == table.RowNum*table.ColNum
  838. count := 0
  839. for _, trs := range table.TRs {
  840. for _, td := range trs.TDs {
  841. if td.BH {
  842. count++
  843. }
  844. }
  845. }
  846. if float32(count)/float32(table.TDNum) < 0.85 {
  847. //精确计算起止行列是表头的概率
  848. table.ComputeRowColIsKeyRation()
  849. bhead := false
  850. L:
  851. for i, tr := range table.TRs {
  852. for _, td := range tr.TDs {
  853. if td.BH {
  854. //qutil.Debug("----=====---", td.Val, len(table.TRs[len(table.TRs)-1].TDs), i, len(table.TRs)-1)
  855. if i == len(table.TRs)-1 && len(table.TRs[len(table.TRs)-1].TDs) == 2 {
  856. res, _, _, _, _ := CheckCommon(td.Val, "abandontable")
  857. if res {
  858. //删除此行
  859. table.TRs = table.TRs[:len(table.TRs)-1]
  860. table.Adjust()
  861. return
  862. }
  863. }
  864. bhead = true
  865. break L
  866. }
  867. }
  868. }
  869. table.BHeader = bhead
  870. }
  871. }
  872. //计算行/列表格的结束位置 StartRow=0 EndRow=0
  873. func (table *Table) ComputeRowColSpan() {
  874. mapRC := map[int]map[int]int{} //记录第几行pos,起始列对应的合并值
  875. for k, v := range table.TRs {
  876. nk := 0 //nk列的起始,k行的起始||如果有合并,起始就不是0
  877. ball := true
  878. rowspans := v.TDs[0].Rowspan //某一行第一个td的rowspan
  879. for _, v1 := range v.TDs {
  880. if v1.Rowspan != rowspans {
  881. ball = false
  882. break
  883. }
  884. }
  885. for _, v1 := range v.TDs {
  886. if ball {
  887. v1.Rowspan = 1
  888. }
  889. mc := mapRC[k]
  890. for {
  891. if mc != nil && mc[nk] > 0 {
  892. nk += mc[nk]
  893. } else {
  894. break
  895. }
  896. }
  897. v1.StartCol = nk
  898. nk += v1.Colspan - 1
  899. v1.EndCol = nk
  900. if nk >= table.ColNum {
  901. table.ColNum = nk + 1
  902. }
  903. nk++
  904. v1.StartRow = k
  905. v1.EndRow = k + v1.Rowspan - 1
  906. ck := fmtkey("c", v1.StartCol, v1.EndCol)
  907. tdcs := table.StartAndEndRation[ck]
  908. if tdcs == nil {
  909. tdcs = NewTDRationScope(ck)
  910. table.StartAndEndRation[ck] = tdcs
  911. table.StartAndEndRationKSort.AddKey(ck, 1)
  912. }
  913. tdcs.Addtd(v1)
  914. rk := fmtkey("r", v1.StartRow, v1.EndRow)
  915. tdrs := table.StartAndEndRation[rk]
  916. if tdrs == nil {
  917. tdrs = NewTDRationScope(rk)
  918. table.StartAndEndRation[rk] = tdrs
  919. table.StartAndEndRationKSort.AddKey(rk, 1)
  920. }
  921. tdrs.Addtd(v1)
  922. if v1.Rowspan > 1 {
  923. for i := 1; i < v1.Rowspan; i++ {
  924. r := k + i
  925. if r < len(table.TRs) {
  926. mc := mapRC[r]
  927. if mc == nil {
  928. mc = map[int]int{}
  929. }
  930. mc[v1.StartCol] = v1.Colspan
  931. mapRC[r] = mc
  932. }
  933. }
  934. }
  935. }
  936. }
  937. }
  938. func fmtkey(t string, start, end int) string {
  939. return fmt.Sprintf("%s_%d_%d", t, start, end)
  940. }
  941. func (table *Table) FindTag() {
  942. //查找每个table的标签,如果有标签可按标签处理,否则根据表格去判断
  943. if table.Tag != "" {
  944. return
  945. }
  946. t1, _ := table.Goquery.OuterHtml()
  947. html := table.Html
  948. pos := strings.Index(html, t1)
  949. if pos <= 0 {
  950. doc, _ := goquery.NewDocumentFromReader(strings.NewReader(table.Html))
  951. html, _ = doc.Html()
  952. pos = strings.Index(html, t1)
  953. }
  954. //u.Debug("--------", t1, "====\n\n\n\n=====", html)
  955. if pos > 0 {
  956. tcon := html[:pos]
  957. tcon = cut.ClearHtml(tcon)
  958. tcon = ClearTagReg.ReplaceAllString(tcon, "")
  959. //u.Debug(pos, "-----------", tcon)
  960. strs := ttagreg.FindStringSubmatch(tcon)
  961. if len(strs) > 0 {
  962. table.Tag = strs[0]
  963. //u.Debug(table.Tag)
  964. }
  965. }
  966. if table.Tag == "" {
  967. table.Tag = table.TableResult.BlockTag
  968. }
  969. //u.Debug(table.Tag)
  970. }
  971. //计算r/c_start_end的概率
  972. func (table *Table) GetKeyRation() {
  973. for _, vn := range table.StartAndEndRationKSort.Keys {
  974. v := table.StartAndEndRation[vn]
  975. for _, v1 := range v.Poss {
  976. count := 0
  977. n := 0
  978. for _, td := range v.Tdmap[v1] {
  979. n++
  980. if td.BH {
  981. count++
  982. }
  983. }
  984. v.Rationmap[v1] = float32(count) / float32(n)
  985. }
  986. }
  987. }
  988. //计算行列是表头的概率调用GetKeyRation
  989. func (table *Table) ComputeRowColIsKeyRation() {
  990. //增加对跨行校正限止
  991. // u.Debug(table.Brule, table.ColNum, table.RowNum, table.TDNum)
  992. bkeyfirstrow := false
  993. bkeyfirstcol := false
  994. if table.Brule { //不存在跨行跨列的情况,规则表格
  995. checkCompute := map[string]bool{}
  996. for k, tr := range table.TRs {
  997. rk := fmtkey("r", tr.TDs[0].StartRow, tr.TDs[0].EndRow)
  998. if k == 0 { //第1行的概率
  999. ck := fmtkey("c", tr.TDs[0].StartCol, tr.TDs[0].EndCol)
  1000. //u.Debug(table.BFirstRow, "--", table.StartAndEndRation[rk], table.StartAndEndRation[ck])
  1001. ration1, _ := table.StartAndEndRation[rk].GetTDRation(tr.TDs[0])
  1002. ration2, _ := table.StartAndEndRation[ck].GetTDRation(tr.TDs[0])
  1003. if (len(tr.TDs) == 2 && ration2 < 0.55) && (len(tr.TDs) == 2 && ration1 > 0.5) { //第一行为key
  1004. bkeyfirstrow = true
  1005. ball := true
  1006. for _, td := range tr.TDs {
  1007. if MoneyReg.MatchString(td.Val) {
  1008. bkeyfirstrow = false
  1009. ball = false
  1010. td.BH = false
  1011. break
  1012. }
  1013. }
  1014. for _, td := range tr.TDs {
  1015. if ball {
  1016. td.BH = true
  1017. td.KeyDirect = 1
  1018. td.KVDirect = 2
  1019. }
  1020. }
  1021. } else if ration2 > 0.55 { //第1列
  1022. bkeyfirstcol = true
  1023. if !checkCompute[ck] {
  1024. checkCompute[ck] = true
  1025. //重置第1列
  1026. for _, tr1 := range table.TRs {
  1027. for _, td1 := range tr1.TDs {
  1028. if td1.StartCol == 0 {
  1029. if !MoneyReg.MatchString(td1.Val) {
  1030. td1.BH = true
  1031. td1.KeyDirect = 2
  1032. td1.KVDirect = 1
  1033. }
  1034. }
  1035. }
  1036. }
  1037. }
  1038. }
  1039. if !bkeyfirstrow && !bkeyfirstcol {
  1040. if len(tr.TDs) > 1 && ration1 > ration2 && ration1 > 0.5 {
  1041. bkeyfirstrow = true
  1042. for _, td := range tr.TDs {
  1043. if !MoneyReg.MatchString(td.Val) {
  1044. td.BH = true
  1045. td.KeyDirect = 1
  1046. td.KVDirect = 2
  1047. }
  1048. }
  1049. } else if tr.Table.ColNum > 1 && ration2 > 0.5 {
  1050. bkeyfirstcol = true
  1051. if !checkCompute[ck] {
  1052. checkCompute[ck] = true
  1053. //重置第1列
  1054. for _, tr1 := range table.TRs {
  1055. for _, td1 := range tr1.TDs {
  1056. if td1.StartCol == 0 {
  1057. if !MoneyReg.MatchString(td1.Val) {
  1058. td1.BH = true
  1059. td1.KeyDirect = 2
  1060. td1.KVDirect = 1
  1061. }
  1062. }
  1063. }
  1064. }
  1065. }
  1066. }
  1067. }
  1068. } else {
  1069. if bkeyfirstrow {
  1070. //第一列的概率
  1071. ration1, _ := table.StartAndEndRation[rk].GetTDRation(tr.TDs[0])
  1072. if k == 1 || ration1 < checkval {
  1073. for _, td := range tr.TDs {
  1074. if !td.MustBH {
  1075. td.BH = false
  1076. td.KeyDirect = 0
  1077. td.KVDirect = 0
  1078. }
  1079. }
  1080. } //else {for _, td := range tr.TDs {}}
  1081. } else {
  1082. //列在起作用
  1083. if bkeyfirstcol {
  1084. for _, td := range tr.TDs {
  1085. ck := fmtkey("c", td.StartCol, td.EndCol)
  1086. ration1, _ := table.StartAndEndRation[ck].GetTDRation(td)
  1087. if !checkCompute[ck] {
  1088. checkCompute[ck] = true
  1089. if ration1 >= checkval && td.ColPos != 1 {
  1090. for _, tr1 := range table.TRs {
  1091. for _, td1 := range tr1.TDs {
  1092. if td1.StartCol == td.StartCol {
  1093. if !MoneyReg.MatchString(td1.Val) {
  1094. td1.BH = true
  1095. td1.KeyDirect = 2
  1096. td1.KVDirect = 1
  1097. }
  1098. }
  1099. }
  1100. }
  1101. } else {
  1102. for _, tr1 := range table.TRs[1:] {
  1103. for _, td1 := range tr1.TDs[1:] {
  1104. if td1.StartCol == td.StartCol && !td1.MustBH {
  1105. td1.BH = false
  1106. td1.KeyDirect = 0
  1107. td1.KVDirect = 0
  1108. }
  1109. }
  1110. }
  1111. }
  1112. }
  1113. }
  1114. }
  1115. }
  1116. }
  1117. }
  1118. }
  1119. //qutil.Debug("table.Brule", table.Brule, !bkeyfirstcol && !bkeyfirstrow)
  1120. if !table.Brule || (!bkeyfirstcol && !bkeyfirstrow) {
  1121. //断行问题,虽然同列或同行,但中间被跨行截断,表格方向调整
  1122. for _, k := range table.StartAndEndRationKSort.Keys {
  1123. v := table.StartAndEndRation[k]
  1124. //横向判断,要判断最多的方向,否则会出现不定的情况(map遍历问题)
  1125. k1 := k[:1]
  1126. for _, v2 := range v.Poss {
  1127. lentds := len(v.Tdmap[v2])
  1128. if v.Rationmap[v2] > checkval {
  1129. for _, td := range v.Tdmap[v2] {
  1130. if td.KeyDirect == 0 && !MoneyReg.MatchString(td.Val) {
  1131. if k1 == "r" {
  1132. ck := fmtkey("c", td.StartCol, td.EndCol)
  1133. rt := table.StartAndEndRation[ck]
  1134. //clen := 0
  1135. var fv float32
  1136. var tdn []*TD
  1137. if rt != nil {
  1138. fv, tdn = rt.GetTDRation(td)
  1139. //clen = len(tdn)
  1140. }
  1141. if lentds > 1 {
  1142. if ((tdn != nil && v.Rationmap[v2] > fv) || tdn == nil) && td.Valtype != "BO" {
  1143. td.KeyDirect = 1
  1144. td.KVDirect = 2
  1145. td.BH = true
  1146. }
  1147. }
  1148. } else {
  1149. ck := fmtkey("r", td.StartRow, td.EndRow)
  1150. rt := table.StartAndEndRation[ck]
  1151. var fv float32
  1152. var tdn []*TD
  1153. //clen := 0
  1154. if rt != nil {
  1155. fv, tdn = rt.GetTDRation(td)
  1156. //clen = len(tdn)
  1157. }
  1158. if lentds > 1 {
  1159. if ((tdn != nil && v.Rationmap[v2] > fv) || tdn == nil) && td.Valtype != "BO" {
  1160. td.KeyDirect = 2
  1161. td.KVDirect = 1
  1162. td.BH = true
  1163. }
  1164. }
  1165. }
  1166. } else {
  1167. break
  1168. }
  1169. }
  1170. } else if v.Rationmap[v2] < 0.5 && len(v.Tdmap[v2]) > 3 {
  1171. for _, td := range v.Tdmap[v2] {
  1172. // u.Debug(td.Val, "-----", td.BH)
  1173. if td.KeyDirect == 0 && td.BH && !td.MustBH {
  1174. if k1 == "r" {
  1175. ck := fmtkey("c", td.StartCol, td.EndCol)
  1176. rt := table.StartAndEndRation[ck]
  1177. clen := 0
  1178. var fv float32
  1179. var tdn []*TD
  1180. if rt != nil {
  1181. fv, tdn = rt.GetTDRation(td)
  1182. clen = len(tdn)
  1183. }
  1184. if lentds >= clen && lentds > 1 {
  1185. if (tdn != nil && v.Rationmap[v2] < fv) || tdn == nil {
  1186. td.BH = false
  1187. }
  1188. }
  1189. } else {
  1190. ck := fmtkey("r", td.StartRow, td.EndRow)
  1191. rt := table.StartAndEndRation[ck]
  1192. var fv float32
  1193. var tdn []*TD
  1194. clen := 0
  1195. if rt != nil {
  1196. fv, tdn = rt.GetTDRation(td)
  1197. clen = len(tdn)
  1198. }
  1199. if lentds >= clen && lentds > 1 {
  1200. if (tdn != nil && v.Rationmap[v2] < fv) || tdn == nil {
  1201. td.BH = false
  1202. }
  1203. }
  1204. }
  1205. } else {
  1206. break
  1207. }
  1208. }
  1209. }
  1210. }
  1211. }
  1212. }
  1213. table.GetKeyRation()
  1214. if len(table.TRs) > 0 && len(table.TRs[0].TDs) > 0 {
  1215. t0 := table.TRs[0].TDs[0]
  1216. key := fmtkey("r", t0.StartRow, t0.EndRow)
  1217. r, t := table.StartAndEndRation[key].GetTDRation(t0)
  1218. if r > 0.9 && len(t) > 1 {
  1219. table.BFirstRow = true
  1220. }
  1221. for k, tr := range table.TRs {
  1222. if len(tr.TDs) == 1 && tr.TDs[0].StartCol == 0 && tr.TDs[0].EndCol+1 == table.ColNum {
  1223. tr.TDs[0].BH = false
  1224. tr.TDs[0].KVDirect = 0
  1225. sv := FindKv(tr.TDs[0].Val, "", 2)
  1226. _, resm := colonkvEntity.entrance(tr.TDs[0].Val, "", 2)
  1227. for k, v := range resm {
  1228. sv.AddKey(k, v)
  1229. }
  1230. if len(sv.Keys) > 0 {
  1231. for k1, v1 := range sv.Map {
  1232. if tr.TDs[0].SortKV.Map[k1] == nil {
  1233. table.SortKV.AddKey(k1, v1)
  1234. }
  1235. }
  1236. } else if table.Tag == "" && k == 0 && len(tr.TDs[0].Val) > 11 {
  1237. table.Tag = tr.TDs[0].Val
  1238. }
  1239. // subVal := tdval_reg.FindAllStringSubmatch(tr.TDs[0].Val, -1)
  1240. // //u.Debug(tr.TDs[0].Val, subVal)
  1241. // if len(subVal) > 0 {
  1242. // for _, subv1 := range subVal {
  1243. // if len(subv1) == 3 {
  1244. // table.SortKV.AddKey(subv1[1], subv1[2])
  1245. // }
  1246. // }
  1247. // } else if k == 0 && len(tr.TDs[0].Val) > 11 {
  1248. // table.Tag = tr.TDs[0].Val
  1249. // }
  1250. }
  1251. // for _, td := range tr.TDs {
  1252. // u.Debug(td.BH, td.Val, "----")
  1253. // }
  1254. }
  1255. }
  1256. }
  1257. //查找表格的kv,调用FindTdVal
  1258. func (table *Table) FindKV() {
  1259. //判断全是key的表格不再查找
  1260. if table.BHeader { //只要一个是key即为true
  1261. direct := If(table.BFirstRow, 2, 1).(int) //kv,2查找方向,向上查找
  1262. vdirect := If(direct == 2, 1, 2).(int)
  1263. //控制跨行表格
  1264. bcon := false
  1265. //增加表格切块判断,只判断切块分包
  1266. //控制中标人排序方向
  1267. bodirect := 0
  1268. //控制中标人排序数值
  1269. sort := 1
  1270. //开始抽取
  1271. for _, tr := range table.TRs {
  1272. if len(tr.TDs) == 1 {
  1273. bcon = false
  1274. td := tr.TDs[0]
  1275. if td.StartCol == 0 && td.EndCol+1 == table.ColNum && len([]rune(td.Val)) > 4 && len([]rune(td.Val)) < 50 {
  1276. res, _, _, _, _ := CheckCommon(td.Val, "abandontable")
  1277. if res { //以下内容丢弃
  1278. bcon = true
  1279. }
  1280. }
  1281. }
  1282. if bcon {
  1283. continue
  1284. }
  1285. if tr.TDs[0].StartRow > 0 {
  1286. numbh := 0
  1287. for _, td := range tr.TDs {
  1288. if td.BH {
  1289. numbh++
  1290. }
  1291. }
  1292. if numbh > 0 && numbh <= len(tr.TDs)/2 {
  1293. direct, vdirect = 1, 2
  1294. } else {
  1295. direct, vdirect = 2, 1
  1296. }
  1297. }
  1298. for _, td := range tr.TDs {
  1299. /**
  1300. rt := table.StartAndEndRation[fmtkey("r", td.StartCol, td.EndCol)]
  1301. if rt != nil {
  1302. r, t := rt.GetTDRation(td)
  1303. u.Debug(td.BH, td.Val, r, t)
  1304. }
  1305. **/
  1306. // if td.Val == "电视" || td.Val == "电话机" || td.Val == "传真机" || td.Val == "音响" {
  1307. // qutil.Debug("----", "td.BH:", td.BH, "KVDirect:", td.KVDirect, "Val:", td.Val, "direct:", direct, "vdirect:", vdirect)
  1308. // }
  1309. if !td.BH && td.KVDirect < 3 {
  1310. if !table.FindTdVal(td, direct, vdirect) {
  1311. if !table.FindTdVal(td, vdirect, direct) {
  1312. //都识别不到时,对第一、二中标候选人的处理
  1313. bo, res := GetBidOrder(td, bodirect, sort)
  1314. if res {
  1315. sort++
  1316. bodirect = bo
  1317. }
  1318. }
  1319. }
  1320. //fmt.Println("td:", td.Val, td.BH, td.HeadTd, td.KVDirect)
  1321. }
  1322. }
  1323. }
  1324. //qutil.Debug("FindKV", table.SortKV.Map)
  1325. } else if len(table.TRs) > 0 { //没有表头的表格处理,默认纵向吧
  1326. res := make([][]string, len(table.TRs[0].TDs))
  1327. for n, _ := range res {
  1328. res[n] = []string{}
  1329. }
  1330. for _, tr := range table.TRs {
  1331. for n, td := range table.TRs[0].TDs { //第一行的所有td
  1332. td1 := table.GetTdByRCNo(tr.TDs[0].StartRow, td.StartCol)
  1333. if td1 != nil {
  1334. res[n] = append(res[n], td1.Val)
  1335. } else {
  1336. res[n] = append(res[n], "")
  1337. }
  1338. }
  1339. }
  1340. //再拆值,类似http://www.ggzy.hi.gov.cn/cgzbgg/16553.jhtml第二列,有多个值
  1341. nmapkeys := []int{}
  1342. nmap := map[int][]*u.Kv{}
  1343. L:
  1344. for _, r1 := range res {
  1345. for n, r := range r1 {
  1346. if len([]rune(r)) < 60 { // 长度小于60才去分
  1347. //res1, _ := GetKVAll(r, "", nil)
  1348. res1, _ := colonkvEntity.entrance(r, "", 2)
  1349. if res1 != nil {
  1350. nmap[n] = res1
  1351. nmapkeys = append(nmapkeys, n)
  1352. /**
  1353. //截取串
  1354. for _k1, _ := range res1 {
  1355. r = regexp.MustCompile(_k1+".*").ReplaceAllString(r, "")
  1356. }
  1357. r1[n] = r
  1358. res[pos] = r1
  1359. **/
  1360. } else if nmap[n] != nil {
  1361. //放空值
  1362. nmap[n] = append(nmap[n], &u.Kv{})
  1363. }
  1364. } else {
  1365. nmap = nil
  1366. nmapkeys = nil
  1367. break L
  1368. }
  1369. }
  1370. }
  1371. //调整
  1372. if len(nmap) > 0 {
  1373. kmapkeys := []string{}
  1374. kmap := map[string][]string{}
  1375. for _, mk := range nmapkeys { //同是第n列
  1376. for pos, m1 := range nmap[mk] {
  1377. k, v := m1.Key, m1.Value
  1378. kv := kmap[k]
  1379. if kv == nil {
  1380. kv = []string{}
  1381. }
  1382. kv = append(kv, v)
  1383. kmap[k] = kv
  1384. kmapkeys = append(kmapkeys, k)
  1385. for _, k := range kmapkeys {
  1386. arr := kmap[k]
  1387. if len(arr) < pos {
  1388. arr = append(arr, "")
  1389. kmap[k] = arr
  1390. kmapkeys = append(kmapkeys, k)
  1391. }
  1392. }
  1393. }
  1394. }
  1395. if len(kmap) > 0 {
  1396. for _, k := range kmapkeys {
  1397. table.SortKV.AddKey(k, kmap[k])
  1398. }
  1399. }
  1400. }
  1401. //=================
  1402. //解析值放到map中
  1403. for _, arr := range res {
  1404. if len(arr) > 0 {
  1405. v1 := arr[0]
  1406. _, _, _, _, repl := CheckCommon(v1, "con")
  1407. if repl == "ENT" {
  1408. table.SortKV.AddKey("中标单位", arr)
  1409. continue
  1410. } else if repl == "BO" {
  1411. table.SortKV.AddKey("排名", arr)
  1412. continue
  1413. }
  1414. }
  1415. }
  1416. }
  1417. //qutil.Debug("FindKV", table.SortKV.Map)
  1418. }
  1419. //获取中标人顺序
  1420. //direct 0默认 1横向 2纵向
  1421. func GetBidOrder(td *TD, direct, n int) (d int, res bool) {
  1422. if td.Valtype != "BO" {
  1423. return
  1424. }
  1425. if td.Rowspan > 1 {
  1426. for i := 0; i < td.Rowspan; i++ {
  1427. nextcol := 1
  1428. L1:
  1429. for {
  1430. vtd := td.TR.Table.GetTdByRCNo(td.StartRow+i, td.EndCol+nextcol)
  1431. if vtd == nil {
  1432. break L1
  1433. }
  1434. nextcol += vtd.Colspan
  1435. if filter_zbdw_v2.MatchString(vtd.Val) {
  1436. arrbo := td.TR.Table.SortKV.Map[NullTxtBid]
  1437. if arrbo == nil {
  1438. arrbo = []map[string]interface{}{}
  1439. td.TR.Table.SortKV.AddKey(NullTxtBid, arrbo)
  1440. }
  1441. a1 := arrbo.([]map[string]interface{})
  1442. a1 = append(a1, map[string]interface{}{
  1443. "entname": vtd.Val,
  1444. "sortstr": td.Val,
  1445. "sort": GetBidSort(td.Val, n),
  1446. })
  1447. res = true
  1448. td.TR.Table.SortKV.Map[NullTxtBid] = a1
  1449. }
  1450. }
  1451. }
  1452. } else if td.Colspan > 1 {
  1453. for i := 1; i < td.Colspan; i++ {
  1454. nextcol := 0
  1455. L2:
  1456. for {
  1457. vtd := td.TR.Table.GetTdByRCNo(td.StartRow+i, td.StartCol+nextcol)
  1458. if vtd == nil || vtd.Colspan >= td.Colspan {
  1459. break L2
  1460. }
  1461. nextcol += vtd.Colspan
  1462. if filter_zbdw_v2.MatchString(vtd.Val) {
  1463. arrbo := td.TR.Table.SortKV.Map[NullTxtBid]
  1464. if arrbo == nil {
  1465. arrbo = []map[string]interface{}{}
  1466. td.TR.Table.SortKV.AddKey(NullTxtBid, arrbo)
  1467. }
  1468. a1 := arrbo.([]map[string]interface{})
  1469. a1 = append(a1, map[string]interface{}{
  1470. "entname": vtd.Val,
  1471. "sortstr": td.Val,
  1472. "sort": GetBidSort(td.Val, n),
  1473. })
  1474. res = true
  1475. td.TR.Table.SortKV.Map[NullTxtBid] = a1
  1476. }
  1477. }
  1478. }
  1479. } else {
  1480. rtd := td.TR.Table.GetTdByRCNo(td.StartRow, td.EndCol+1)
  1481. btd := td.TR.Table.GetTdByRCNo(td.EndRow+1, td.StartCol)
  1482. //if ((rtd != nil && !rtd.BH && rtd.Valtype == "BO") || direct == 1) && btd != nil && filter_zbdw_v.MatchString(btd.Val) {
  1483. if ((rtd != nil && !rtd.BH) || direct == 1) && btd != nil && filter_zbdw_v2.MatchString(btd.Val) {
  1484. d = 1
  1485. arrbo := td.TR.Table.SortKV.Map[NullTxtBid]
  1486. if arrbo == nil {
  1487. arrbo = []map[string]interface{}{}
  1488. td.TR.Table.SortKV.AddKey(NullTxtBid, arrbo)
  1489. }
  1490. a1 := arrbo.([]map[string]interface{})
  1491. a1 = append(a1, map[string]interface{}{
  1492. "entname": btd.Val,
  1493. "sortstr": td.Val,
  1494. "sort": GetBidSort(td.Val, n),
  1495. })
  1496. res = true
  1497. td.TR.Table.SortKV.Map[NullTxtBid] = a1
  1498. //} else if ((btd != nil && !btd.BH && btd.Valtype == "BO") || direct == 2) && rtd != nil && filter_zbdw_v.MatchString(rtd.Val) {
  1499. } else if ((btd != nil && !btd.BH) || direct == 2) && rtd != nil && filter_zbdw_v2.MatchString(rtd.Val) {
  1500. d = 2
  1501. arrbo := td.TR.Table.SortKV.Map[NullTxtBid]
  1502. if arrbo == nil {
  1503. arrbo = []map[string]interface{}{}
  1504. td.TR.Table.SortKV.AddKey(NullTxtBid, arrbo)
  1505. }
  1506. a1 := arrbo.([]map[string]interface{})
  1507. a1 = append(a1, map[string]interface{}{
  1508. "entname": rtd.Val,
  1509. "sortstr": td.Val,
  1510. "sort": GetBidSort(td.Val, n),
  1511. })
  1512. res = true
  1513. td.TR.Table.SortKV.Map[NullTxtBid] = a1
  1514. }
  1515. }
  1516. return
  1517. }
  1518. func GetBidSort(str string, n int) int {
  1519. val := n
  1520. if strings.Index(str, "首选") > -1 {
  1521. val = 1
  1522. } else {
  1523. val = winnerOrderEntity.toNumber(str, n)
  1524. }
  1525. return val
  1526. }
  1527. //查找每一个单元格的表头,调用FindNear
  1528. func (table *Table) FindTdVal(td *TD, direct, vdirect int) (b bool) {
  1529. near := table.FindNear(td, direct)
  1530. // if near != nil {
  1531. // fmt.Println("near----", near.Val, td.Val)
  1532. // }
  1533. if near != nil && near.BH && (near.KeyDirect == vdirect || near.KeyDirect == 0) && (near.KVDirect == direct || near.KVDirect == 0) && near.KVDirect < 3 {
  1534. near.KVDirect = direct
  1535. near.KeyDirect = vdirect
  1536. td.KVDirect = direct
  1537. key := near.Val
  1538. if near.Val == "" {
  1539. key = fmtkey("k", near.TR.RowPos, near.ColPos)
  1540. }
  1541. val := table.SortKV.Map[key]
  1542. //qutil.Debug("====================", "key:", key, "val:", val)
  1543. bthiskey := false
  1544. if val != nil {
  1545. curpos := table.SortKV.Index[key]
  1546. thistr := table.kTD[curpos]
  1547. if thistr != near {
  1548. near.Val += "_"
  1549. for table.SortKV.Map[near.Val] != nil {
  1550. near.Val += "_"
  1551. }
  1552. key = near.Val //之前这个地方没有重置,导致把之前结果覆盖了
  1553. } else {
  1554. bthiskey = true
  1555. }
  1556. }
  1557. bfind := false
  1558. barr := false
  1559. varrpos := -1
  1560. if bthiskey {
  1561. //处理是数组值,且有合并行或合并列的情况 kvscope,对数组值的处理
  1562. pos := table.SortKV.Index[key]
  1563. mval := table.kvscope[pos]
  1564. bvalfind := false
  1565. if direct == 1 { //kv是横向
  1566. L1:
  1567. for k3, v3 := range mval {
  1568. for _, v4 := range v3 {
  1569. if v4.EndRow+1 == td.StartRow && v4.EndCol == td.EndCol {
  1570. varrpos = k3
  1571. bvalfind = true
  1572. break L1
  1573. }
  1574. }
  1575. }
  1576. } else { //kv是纵向
  1577. L2:
  1578. for k3, v3 := range mval {
  1579. for _, v4 := range v3 {
  1580. if v4.EndCol+1 == td.StartCol && v4.EndRow == td.EndRow {
  1581. varrpos = k3
  1582. bvalfind = true
  1583. break L2
  1584. }
  1585. }
  1586. }
  1587. }
  1588. if vals, ok := val.([]string); ok {
  1589. if near.Val == "" {
  1590. bn := false
  1591. for _, vs := range vals {
  1592. if vs != "" && NullTdReg.MatchString(vs) {
  1593. bn = true
  1594. } else {
  1595. bn = false
  1596. break
  1597. }
  1598. }
  1599. if bn {
  1600. near.Val = NullTxtBid
  1601. key = NullTxtBid
  1602. bfind = true
  1603. }
  1604. }
  1605. if bvalfind {
  1606. vals[varrpos] = td.Val // += "__" + td.Val
  1607. } else {
  1608. vals = append(vals, td.Val)
  1609. val = vals
  1610. varrpos = len(vals) - 1
  1611. }
  1612. } else if vals, ok := val.(string); ok {
  1613. if bvalfind {
  1614. val = td.Val //vals + "__" + td.Val
  1615. } else {
  1616. tval := []string{vals}
  1617. tval = append(tval, td.Val)
  1618. val = tval
  1619. varrpos = 1
  1620. }
  1621. }
  1622. barr = true
  1623. } else {
  1624. val = td.Val
  1625. }
  1626. td.HeadTd = near
  1627. if bfind {
  1628. tkey := fmtkey("k", near.TR.RowPos, near.ColPos)
  1629. table.SortKV.ReplaceKey(key, val, tkey)
  1630. } else {
  1631. table.SortKV.AddKey(key, val)
  1632. //if table.SortKV.Map[key] != nil {
  1633. pos := table.SortKV.Index[key]
  1634. //qutil.Debug("=========", "key:", key, "val:", val, "pos:", pos)
  1635. if barr {
  1636. mval := table.kvscope[pos]
  1637. if mval != nil {
  1638. tds := mval[varrpos]
  1639. if tds != nil {
  1640. tds = append(tds, td)
  1641. } else {
  1642. tds = []*TD{td}
  1643. }
  1644. if varrpos > -1 {
  1645. mval[varrpos] = tds
  1646. table.kvscope[pos] = mval
  1647. }
  1648. }
  1649. } else {
  1650. table.kvscope[pos] = map[int][]*TD{
  1651. 0: []*TD{td},
  1652. }
  1653. table.kTD[pos] = near
  1654. }
  1655. //}
  1656. }
  1657. b = true
  1658. }
  1659. //qutil.Debug("map", b, table.SortKV.Map)
  1660. return
  1661. }
  1662. //查找单元格的表头时,横向或纵向
  1663. func (table *Table) FindNear(td *TD, direct int) *TD {
  1664. if direct == 1 && td.StartCol > 0 { //左临
  1665. tr := table.TRs[:td.TR.RowPos+1]
  1666. for i := len(tr) - 1; i > -1; i-- {
  1667. tds := tr[i].TDs
  1668. for _, td1 := range tds {
  1669. if td1.StartRow <= td.StartRow && td1.EndRow >= td.EndRow && td1.EndCol+1 == td.StartCol {
  1670. //找到左临节点
  1671. if td1.BH {
  1672. return td1
  1673. } else {
  1674. if td1.HeadTd != nil && td1.HeadTd.KVDirect == direct {
  1675. return td1.HeadTd
  1676. }
  1677. }
  1678. }
  1679. }
  1680. }
  1681. } else if direct == 2 && td.StartRow > 0 { //上临
  1682. tr := table.TRs[:td.TR.RowPos]
  1683. for i := len(tr) - 1; i > -1; i-- {
  1684. tds := tr[i].TDs
  1685. for _, td1 := range tds {
  1686. if td1.StartCol <= td.StartCol && td1.EndCol >= td.EndCol && td1.EndRow+1 == td.StartRow {
  1687. //找到左临节点
  1688. if td1.BH {
  1689. return td1
  1690. } else {
  1691. if td1.HeadTd != nil && td1.HeadTd.KVDirect == direct {
  1692. return td1.HeadTd
  1693. }
  1694. }
  1695. }
  1696. }
  1697. }
  1698. }
  1699. return nil
  1700. }
  1701. //根据行号列号获取td对象
  1702. func (tn *Table) GetTdByRCNo(row, col int) *TD {
  1703. for _, tr := range tn.TRs {
  1704. for _, td := range tr.TDs {
  1705. if td.StartCol <= col && td.EndCol >= col && td.StartRow <= row && td.EndRow >= row {
  1706. return td
  1707. }
  1708. }
  1709. }
  1710. return nil
  1711. }
  1712. //判断表格是否是分包
  1713. func (tn *Table) CheckMultiPackageByTable() (b bool, index []string) {
  1714. pac := 0
  1715. val := 0
  1716. index = []string{}
  1717. index_pos := []int{}
  1718. //是数组且能找到标段之类的提示
  1719. arr_count := 0
  1720. key_index := -1
  1721. hasPkgTd := map[string]bool{}
  1722. for in, k := range tn.SortKV.Keys {
  1723. if excludeKey.MatchString(BracketsTextReg.ReplaceAllString(k, "")) {
  1724. continue
  1725. }
  1726. v := tn.SortKV.Map[k]
  1727. vs, bvs := v.([]string)
  1728. if bvs {
  1729. arr_count++
  1730. haspkgs := []string{}
  1731. for in2, v1 := range vs {
  1732. v1 = replPkgConfusion(v1)
  1733. if len([]rune(v1)) < 8 && !moneyNum.MatchString(v1) && FindVal_1.MatchString(v1) {
  1734. if key_index == -1 {
  1735. key_index = in
  1736. } else if key_index != in {
  1737. break
  1738. }
  1739. index = append(index, FindVal_1.FindString(v1))
  1740. index_pos = append(index_pos, in2)
  1741. val += 1
  1742. pac++
  1743. } else {
  1744. if ok, v1new := isHasOnePkgAndNoKv(v1); ok {
  1745. haspkgs = append(haspkgs, v1new)
  1746. }
  1747. }
  1748. }
  1749. /*处理这种情况:
  1750. <tr><td>包一:xxxxxxxxx</td></tr>
  1751. <tr><td>包二:xxxxxxxxx</td></tr>
  1752. */
  1753. if len(index) == 0 && len(haspkgs) > 0 && len(haspkgs) == len(vs) {
  1754. for in2, v1 := range haspkgs {
  1755. if key_index == -1 {
  1756. key_index = in
  1757. } else if key_index != in {
  1758. break
  1759. }
  1760. index = append(index, v1)
  1761. index_pos = append(index_pos, in2)
  1762. val += 1
  1763. pac++
  1764. }
  1765. }
  1766. } else if v1, ok := v.(string); ok {
  1767. v1 = replPkgConfusion(v1)
  1768. if len([]rune(v1)) < 8 && !moneyNum.MatchString(v1) && FindVal_1.MatchString(v1) {
  1769. key_index = in
  1770. index = append(index, FindVal_1.FindString(v1))
  1771. index_pos = append(index_pos, 0)
  1772. val += 1
  1773. pac++
  1774. } else if getTd := tn.GetTdByRCNo(0, tn.SortKV.Index[k]); getTd != nil && getTd.KVDirect == 2 {
  1775. /*处理这种情况:
  1776. <tr><td>包一:xxxxxxxxx</td></tr>
  1777. */
  1778. if ok, v1new := isHasOnePkgAndNoKv(v1); ok {
  1779. hasPkgTd[k] = true
  1780. key_index = in
  1781. index = append(index, v1new)
  1782. index_pos = append(index_pos, 0)
  1783. val += 1
  1784. pac++
  1785. }
  1786. }
  1787. }
  1788. }
  1789. //key是分包的情况
  1790. //记录key对应的值
  1791. commonKeyVals := map[string][]string{}
  1792. //记录key出现的次数
  1793. keyExistsCount := map[string]int{}
  1794. if pac > 1 {
  1795. val = 10
  1796. } else {
  1797. //查找标签
  1798. if TableMultiPackageReg_4.MatchString(tn.Tag) {
  1799. val += 4
  1800. } else if TableMultiPackageReg_2.MatchString(tn.Tag) {
  1801. val += 4
  1802. }
  1803. keyIsPkg := false
  1804. for in, k := range tn.SortKV.Keys {
  1805. if excludeKey.MatchString(BracketsTextReg.ReplaceAllString(k, "")) {
  1806. continue
  1807. }
  1808. v := tn.SortKV.Map[k]
  1809. //key是分包的情况
  1810. if ismatch := FindVal_1.MatchString(k); keyIsPkg || ismatch {
  1811. if ismatch {
  1812. keyIsPkg = true
  1813. val += 4
  1814. pkgFlag := FindVal_1.FindString(k)
  1815. k = strings.Replace(k, pkgFlag, "", -1)
  1816. index = append(index, pkgFlag)
  1817. index_pos = append(index_pos, len(index))
  1818. val += 1
  1819. pac++
  1820. } else {
  1821. k = strings.TrimRight(k, "_")
  1822. }
  1823. keyExistsCount[k] = keyExistsCount[k] + 1
  1824. commonKeyVals[k] = append(commonKeyVals[k], qutil.ObjToString(v))
  1825. } else if k1 := FilterKey_2.ReplaceAllString(k, ""); FindKey_2.MatchString(k1) {
  1826. val += 4
  1827. if vs, bvs1 := v.([]string); bvs1 {
  1828. L:
  1829. for in2, v1 := range vs {
  1830. if len([]rune(v1)) < 20 && !moneyNum.MatchString(v1) && FindVal2_1.MatchString(v1) {
  1831. for _, serial := range regSerialTitles_2 {
  1832. if serial.MatchString(v1) {
  1833. break L
  1834. }
  1835. }
  1836. if key_index == -1 {
  1837. key_index = in
  1838. } else if key_index != in {
  1839. break
  1840. }
  1841. index = append(index, v1)
  1842. index_pos = append(index_pos, in2)
  1843. val += 1
  1844. pac++
  1845. }
  1846. }
  1847. } else if v1, ok := v.(string); ok && !hasPkgTd[k] {
  1848. v1 = replPkgConfusion(v1)
  1849. for _, v2 := range strings.Split(v1, "/") {
  1850. if len([]rune(v2)) < 20 && !moneyNum.MatchString(v2) && FindVal2_1.MatchString(v2) {
  1851. key_index = in
  1852. index = append(index, v1)
  1853. index_pos = append(index_pos, 0)
  1854. val += 1
  1855. pac++
  1856. underline := ""
  1857. for {
  1858. underline += "_"
  1859. if tn.SortKV.Map[k+underline] == nil {
  1860. break
  1861. } else if v3, v2_ok := tn.SortKV.Map[k+underline].(string); v2_ok && v3 != "" {
  1862. index = append(index, v3)
  1863. index_pos = append(index_pos, 1)
  1864. } else if v3, v2_ok := tn.SortKV.Map[k+underline].([]string); v2_ok {
  1865. for v2_k, v2_v := range v3 {
  1866. index = append(index, v2_v)
  1867. index_pos = append(index_pos, v2_k+1)
  1868. }
  1869. }
  1870. }
  1871. break
  1872. }
  1873. }
  1874. }
  1875. break
  1876. }
  1877. }
  1878. }
  1879. // u.Debug(index)
  1880. //过滤重复及标准化!
  1881. standIndex := []string{}
  1882. standIndex_pos := []int{}
  1883. oldIndex := []string{}
  1884. brepeat := map[string]bool{}
  1885. for k, v := range index {
  1886. v = u.PackageNumberConvert(v)
  1887. if !brepeat[v] {
  1888. brepeat[v] = true
  1889. standIndex = append(standIndex, v)
  1890. standIndex_pos = append(standIndex_pos, index_pos[k])
  1891. oldIndex = append(oldIndex, v)
  1892. }
  1893. }
  1894. index = standIndex
  1895. //有一个以上的包,并且相同的key出现一次以上,认为这个key是属于包里面的
  1896. if len(commonKeyVals) > 0 {
  1897. for k, v := range commonKeyVals {
  1898. if len(index) > 1 && keyExistsCount[k] < 2 {
  1899. continue
  1900. }
  1901. tn.SortKV.AddKey(k, v)
  1902. }
  1903. }
  1904. //
  1905. isGoonNext := false
  1906. if val > 4 && len(brepeat) > 0 {
  1907. b = true
  1908. //多包解析
  1909. if b {
  1910. tn.BPackage = true
  1911. for nk, v := range index {
  1912. if tn.BlockPackage.Map[v] == nil {
  1913. bp := &u.BlockPackage{}
  1914. bp.Index = v
  1915. bp.Origin = oldIndex[nk]
  1916. bp.TableKV = u.NewJobKv()
  1917. tn.BlockPackage.AddKey(v, bp)
  1918. }
  1919. }
  1920. if len(index) == 1 { //是一个的情况
  1921. if len(tn.SortKV.Keys) < 10 && tn.ColNum < 10 && tn.RowNum < 4 {
  1922. beq := true
  1923. for _, v2 := range tn.SortKV.Map {
  1924. if _, ok := v2.(string); !ok {
  1925. beq = false
  1926. break
  1927. }
  1928. }
  1929. if beq { //统一处理为数组
  1930. td := tn.GetTdByRCNo(tn.RowNum-1, 0)
  1931. if !td.BH && FindVal2_1.MatchString(td.Val) {
  1932. for k2, v2 := range tn.SortKV.Map {
  1933. tn.SortKV.Map[k2] = []string{v2.(string)}
  1934. }
  1935. } else {
  1936. //没有处理成数组的情况下,继续调用正文查找分包的方法
  1937. isGoonNext = true
  1938. }
  1939. }
  1940. }
  1941. }
  1942. for _, k1 := range tn.SortKV.Keys {
  1943. v1 := tn.SortKV.Map[k1]
  1944. if _, bvs := v1.(string); bvs && len(index) > 1 && !strings.HasSuffix(k1, "_") {
  1945. v1_array := []string{v1.(string)}
  1946. underline := ""
  1947. for {
  1948. underline += "_"
  1949. if tn.SortKV.Map[k1+underline] == nil {
  1950. break
  1951. } else if v3, v2_ok := tn.SortKV.Map[k1+underline].(string); v2_ok && v3 != "" {
  1952. v1_array = append(v1_array, v3)
  1953. }
  1954. }
  1955. v1 = v1_array
  1956. }
  1957. if val, bvs := v1.([]string); bvs {
  1958. if len(val) <= len(index) {
  1959. for k, v := range val {
  1960. tn.assemblePackage(k1, v, index[k])
  1961. }
  1962. } else {
  1963. for sk1, sv2 := range index {
  1964. v := val[sk1]
  1965. //处理http://www.hljcg.gov.cn/xwzs!queryOneXwxxqx.action?xwbh=8145b599-a11e-45cb-a76a-12157a715570
  1966. if v == "" && strings.Index(k1, "供应商") > -1 {
  1967. if sk1 != len(index)-1 {
  1968. //u.Debug(val[sk1+1], val[sk1+2])
  1969. if standIndex_pos[sk1+1]-standIndex_pos[sk1] > 1 {
  1970. v = val[standIndex_pos[sk1]+1]
  1971. }
  1972. } else {
  1973. if standIndex_pos[sk1] < len(val)-1 {
  1974. v = val[standIndex_pos[sk1]+1]
  1975. }
  1976. }
  1977. }
  1978. tn.assemblePackage(k1, v, sv2)
  1979. }
  1980. }
  1981. //删除子包的kv
  1982. //u.Debug("----==1==-------", k1)
  1983. k1tags := u.GetTags(k1)
  1984. if !(len(k1tags) > 0 && k1tags[0].Value == "采购单位") {
  1985. tn.SortKV.RemoveKey(k1)
  1986. }
  1987. } else if val, bvs := v1.(string); bvs && len(index) == 1 {
  1988. //删除子包的kv
  1989. k1tags, _, _, _, _ := CommonDataAnaly(k1, "", "", val)
  1990. if !(len(k1tags) > 0 && regexp.MustCompile("^(项目|开标|采购单位|招标机构)").MatchString(k1tags[0])) { //(k1tags[0].Value == "采购单位" || k1tags[0].Value == "项目编号")) {
  1991. //log.Println("remove", k1, val)
  1992. tn.assemblePackage(k1, val, index[0])
  1993. tn.SortKV.RemoveKey(k1)
  1994. }
  1995. //u.Debug("----==2==-------", k1)
  1996. }
  1997. }
  1998. }
  1999. } else {
  2000. isGoonNext = true
  2001. }
  2002. if isGoonNext {
  2003. blockPackage := map[string]*u.BlockPackage{}
  2004. for _, k := range tn.SortKV.Keys {
  2005. if excludeKey.MatchString(k) {
  2006. continue
  2007. }
  2008. str := ""
  2009. v := tn.SortKV.Map[k]
  2010. nk := regReplAllSpace.ReplaceAllString(k, "")
  2011. if vs, ok := v.([]string); ok {
  2012. str += fmt.Sprintf("%s:%s\n", nk, strings.Join(vs, " "))
  2013. } else {
  2014. str += fmt.Sprintf("%s:%s\n", nk, v)
  2015. }
  2016. b, _ := divisionPackageChild(&blockPackage, str, tn.Tag, false, false)
  2017. if b && len(blockPackage) > 0 {
  2018. tn.BPackage = true
  2019. for mk, mv := range blockPackage {
  2020. if tn.BlockPackage.Map[mk] == nil {
  2021. tn.BlockPackage.AddKey(mk, mv)
  2022. } else {
  2023. bp := tn.BlockPackage.Map[mk].(*u.BlockPackage)
  2024. if bp.TableKV == nil {
  2025. bp.TableKV = u.NewJobKv()
  2026. }
  2027. for k2, v2 := range mv.ColonKV.Kv {
  2028. if bp.TableKV.Kv[k2] == "" {
  2029. bp.TableKV.Kv[k2] = v2
  2030. bp.TableKV.KvTag[k2] = mv.ColonKV.KvTag[k2]
  2031. bp.Text += fmt.Sprintf("%v:%v\n", k2, v2)
  2032. }
  2033. }
  2034. for k2, v2 := range mv.SpaceKV.Kv {
  2035. if bp.TableKV.Kv[k2] == "" {
  2036. bp.TableKV.Kv[k2] = v2
  2037. bp.TableKV.KvTag[k2] = mv.SpaceKV.KvTag[k2]
  2038. bp.Text += fmt.Sprintf("%v:%v\n", k2, v2)
  2039. }
  2040. }
  2041. }
  2042. }
  2043. tn.BPackage = true
  2044. tn.SortKV.RemoveKey(k)
  2045. }
  2046. }
  2047. }
  2048. //查找分包中的中标人排序
  2049. if tn.BlockPackage != nil && tn.BlockPackage.Map != nil && len(tn.BlockPackage.Map) > 0 {
  2050. for _, v := range tn.BlockPackage.Map {
  2051. vv := v.(*u.BlockPackage)
  2052. if vv.WinnerOrder == nil || len(vv.WinnerOrder) == 0 {
  2053. vv.WinnerOrder = winnerOrderEntity.Find(vv.Text, true, 2)
  2054. }
  2055. }
  2056. }
  2057. return
  2058. }
  2059. //组装解析到的分包
  2060. func (tn *Table) assemblePackage(k1, v1, key string) {
  2061. bp := tn.BlockPackage.Map[key].(*u.BlockPackage)
  2062. if bp.TableKV == nil {
  2063. bp.TableKV = u.NewJobKv()
  2064. }
  2065. if v1 != "" {
  2066. k2, w1, v2, _, bf := CommonDataAnaly(k1, "中标情况", "", v1)
  2067. if bf {
  2068. for pos, k3 := range k2 {
  2069. if bp.TableKV.Kv != nil && bp.TableKV.KvTag[k3] != nil && (bp.TableKV.Kv[k3] == "" || w1[pos] > bp.TableKV.KvTag[k3].Weight) {
  2070. bp.TableKV.Kv[k3] = v2
  2071. bp.TableKV.KvTag[k3] = &u.Tag{Value: v2, Weight: w1[pos]}
  2072. }
  2073. }
  2074. } else {
  2075. bp.TableKV.Kv[k1] = qutil.ObjToString(v1)
  2076. }
  2077. }
  2078. k1 = regReplAllSpace.ReplaceAllString(k1, "")
  2079. //拼接内容
  2080. if !excludeKey.MatchString(k1) {
  2081. bp.Text += fmt.Sprintf("%v:%v\n", k1, v1)
  2082. }
  2083. tn.BlockPackage.Map[key] = bp
  2084. }
  2085. /**
  2086. 之前爬虫过来的数据对table表格的抓取异常问题
  2087. 查找并修正不规则表格的字符串,只对全文做处理,块内的表格不需要修正
  2088. **/
  2089. var thbf = regexp.MustCompile("(?i)</?t(head|body|foot)>")
  2090. //需要保留thead
  2091. var saveThead = regexp.MustCompile("(?is)<thead>(.+?)</thead>")
  2092. func RepairCon(con string) string {
  2093. res := saveThead.FindAllStringSubmatch(con, 1)
  2094. th := ""
  2095. if len(res) == 1 && len(res[0]) == 2 {
  2096. th = u.TrimLeftSpace(res[0][1], "")
  2097. }
  2098. con = thbf.ReplaceAllString(con, "")
  2099. con = u.TrimLeftSpace(con, "")
  2100. itbody := strings.Index(con, "<tr")
  2101. iLen := 3
  2102. if itbody == 0 {
  2103. con = findpos(con, iLen, itbody)
  2104. } else {
  2105. itable := strings.Index(con, "<table")
  2106. if itable == -1 || itable > itbody {
  2107. con = findpos(con, iLen, itbody)
  2108. }
  2109. }
  2110. //保留第一个thead
  2111. if th != "" {
  2112. con = strings.Replace(con, th, "<thead>"+th+"</thead>", 1)
  2113. }
  2114. //u.Debug(con)
  2115. return con
  2116. }
  2117. //修复表格
  2118. func findpos(con string, iLen, start int) (newcon string) {
  2119. defer qutil.Catch()
  2120. n := len(con)
  2121. layer := 0
  2122. pos := 0
  2123. if start >= 0 {
  2124. if iLen == 6 {
  2125. for i := iLen + start; i < len(con); i++ {
  2126. if con[i] == '<' && i+6 < n {
  2127. str := con[i : i+6]
  2128. if str == "</tbod" {
  2129. if layer == 0 {
  2130. pos = i
  2131. break
  2132. } else {
  2133. layer--
  2134. }
  2135. i += 6
  2136. } else if str == "<tbody" {
  2137. layer++
  2138. i += 6
  2139. }
  2140. }
  2141. }
  2142. if pos+7 <= n && start+6 < pos {
  2143. newcon = con[:start] + "<table" + con[start+6:pos] + "</table" + con[pos+7:]
  2144. }
  2145. } else {
  2146. layer++
  2147. nq := 0
  2148. lasttr := 0
  2149. for i := iLen + start; i < len(con); i++ {
  2150. if con[i] == '<' && i+4 < n {
  2151. if nq == 0 {
  2152. str := con[i : i+4]
  2153. if str == "</tr" {
  2154. if layer <= 0 {
  2155. pos = i //正常情况不会存在此类情况
  2156. break
  2157. } else {
  2158. layer--
  2159. lasttr = i
  2160. }
  2161. i += 4
  2162. } else if str[:3] == "<tr" {
  2163. layer++
  2164. i += 4
  2165. } else if str == "<tab" && i+6 < n && con[i+4:i+6] == "le" {
  2166. if layer == 0 {
  2167. break
  2168. } else {
  2169. //内嵌的表格
  2170. nq++
  2171. }
  2172. }
  2173. } else {
  2174. if i+6 < n {
  2175. str := con[i : i+6]
  2176. if str == "</tabl" {
  2177. nq--
  2178. } else if str == "<table" {
  2179. nq++
  2180. }
  2181. } else {
  2182. break
  2183. }
  2184. }
  2185. }
  2186. }
  2187. if pos == 0 && lasttr > 3 {
  2188. pos = lasttr + 5
  2189. } else if pos > 0 {
  2190. pos += 5
  2191. }
  2192. if pos <= n && pos < len(con) && start < pos {
  2193. newcon = con[:start] + "<table>" + con[start:pos] + "</table>" + con[pos:]
  2194. }
  2195. }
  2196. }
  2197. if newcon == "" {
  2198. newcon = con
  2199. }
  2200. return
  2201. }
  2202. //td的值里面有一个包,并且没有冒号kv
  2203. func isHasOnePkgAndNoKv(v1 string) (bool, string) {
  2204. v1s := FindVal_1.FindAllString(v1, -1)
  2205. colonCount := len(regDivision.FindAllString(v1, -1))
  2206. if len(v1s) == 1 && colonCount < 2 {
  2207. ispkgcolon := regexp.MustCompile(v1s[0] + "[::]").MatchString(v1)
  2208. if (ispkgcolon && colonCount == 1) || (!ispkgcolon && colonCount == 0) {
  2209. return true, v1s[0]
  2210. }
  2211. }
  2212. return false, v1
  2213. }
  2214. //替换分包中混淆的词
  2215. func replPkgConfusion(v1 string) string {
  2216. v1 = PreReg.ReplaceAllString(v1, "")
  2217. v1 = PreReg1.ReplaceAllString(v1, "")
  2218. v1 = PreCon.ReplaceAllString(v1, "")
  2219. v1 = PreCon2.ReplaceAllString(v1, "")
  2220. return v1
  2221. }
  2222. //对td中的值,进行再处理
  2223. func (tn *Table) TdContactFormat(contactFormat *u.ContactFormat) {
  2224. //处理表格中的联系人信息
  2225. indexMap := contactFormat.IndexMap
  2226. matchMap := contactFormat.MatchMap
  2227. weightMap := map[string]map[string]interface{}{} //权重
  2228. mustMatchFirst := len(indexMap) > 0 //第一个必须匹配上
  2229. reCreate := false
  2230. matchCount := 0
  2231. contactTypeTagMap := map[string]map[string][]interface{}{}
  2232. //u.Debug(mustMatchFirst, indexMap, matchMap)
  2233. notMatchTrCount := 0
  2234. allAscFind := true
  2235. if len(indexMap) == 0 {
  2236. isCanAddToIndexMap := false
  2237. matchPrevFlag := false
  2238. prevCanAddToIndexMap := false
  2239. LS:
  2240. for _, tr := range tn.TRs {
  2241. for td_index, td := range tr.TDs {
  2242. thisTdKvs := colonkvEntity.GetKvs(td.Text, "", 2)
  2243. if len(thisTdKvs) == 0 {
  2244. tdValue := regReplAllSpace.ReplaceAllString(td.Text, "")
  2245. if tdValue != "" && len([]rune(tdValue)) < 10 {
  2246. thisTdKvs = append(thisTdKvs, &u.Kv{
  2247. Key: tdValue,
  2248. Value: "",
  2249. })
  2250. }
  2251. }
  2252. if len(thisTdKvs) != 1 {
  2253. continue
  2254. }
  2255. //采购人在联系人、电话后面的处理
  2256. td_k := FilterContactKey(thisTdKvs[0].Key)
  2257. td_k_length := len([]rune(td_k))
  2258. if td_k_length < 2 || td_k_length > 15 {
  2259. continue
  2260. }
  2261. isContinue := ContactInfoMustReg.MatchString(td_k)
  2262. if isContinue || (ContactInfoVagueReg.MatchString(td_k) && u.IsMapHasValue(td_k, ContactType)) {
  2263. if !matchPrevFlag && len(indexMap) > 0 {
  2264. indexMap = map[int]string{}
  2265. break LS
  2266. }
  2267. isCanAddToIndexMap = true
  2268. }
  2269. if isContinue {
  2270. continue
  2271. }
  2272. for _, k := range HasOrderContactType(td_k) {
  2273. if !ContactType[k].MatchString(td_k) {
  2274. continue
  2275. }
  2276. if len(indexMap) == 0 {
  2277. if isCanAddToIndexMap || (prevCanAddToIndexMap && len(tr.TDs) == 1) {
  2278. myPrevTdVal := ""
  2279. if td_index-2 >= 0 {
  2280. myPrevTdVal = tr.TDs[td_index-2].Val
  2281. }
  2282. if myPrevTdVal != "" && len([]rune(myPrevTdVal)) < 10 && ContactInfoMustReg.MatchString(myPrevTdVal) {
  2283. matchPrevFlag = true
  2284. }
  2285. indexMap[0] = k
  2286. break
  2287. }
  2288. } else {
  2289. indexMap = map[int]string{}
  2290. break LS
  2291. }
  2292. }
  2293. }
  2294. prevCanAddToIndexMap = isCanAddToIndexMap
  2295. isCanAddToIndexMap = false
  2296. }
  2297. if len(indexMap) > 0 {
  2298. allAscFind = false
  2299. }
  2300. }
  2301. //////
  2302. L:
  2303. for tr_index, tr := range tn.TRs {
  2304. thisTrHasMatch := false
  2305. jumpNextTd := false
  2306. for td_index, td := range tr.TDs {
  2307. //和|以?及|与|、多个词和在一起
  2308. if !jumpNextTd && len([]rune(td.Text)) >= 5 && len([]rune(td.Text)) <= 15 && regSplit.MatchString(td.Text) && td_index+1 < len(tr.TDs) {
  2309. thisTdVals := regSplit.Split(td.Text, -1)
  2310. nextTdVals := MultipleValueSplitReg.Split(tr.TDs[td_index+1].Val, -1)
  2311. if len(thisTdVals) == len(nextTdVals) {
  2312. isHandle := false
  2313. for _, k := range HasOrderContactType(td.Text) {
  2314. if ContactType[k].MatchString(td.Text) {
  2315. for thisTdVals_k, thisTdVals_v := range thisTdVals {
  2316. thisTdVals_v = strings.TrimSpace(thisTdVals_v)
  2317. if ContactType[k].MatchString(thisTdVals_v) {
  2318. thisTrHasMatch = true
  2319. tr.TDs[td_index+1].SortKV.AddKey(thisTdVals_v, nextTdVals[thisTdVals_k])
  2320. continue
  2321. }
  2322. if !ContactInfoMustReg.MatchString(thisTdVals_v) {
  2323. continue
  2324. }
  2325. jumpNextTd = true
  2326. thisTrHasMatch = true
  2327. tr.TDs[td_index+1].SortKV.AddKey(k+thisTdVals_v, nextTdVals[thisTdVals_k])
  2328. }
  2329. break
  2330. }
  2331. }
  2332. if !isHandle && len(indexMap) > 0 {
  2333. _, onlyContactType := u.FirstKeyValueInMap(indexMap)
  2334. if myContactType, _ := onlyContactType.(string); myContactType != "" {
  2335. for thisTdVals_k, thisTdVals_v := range thisTdVals {
  2336. thisTdVals_v = strings.TrimSpace(thisTdVals_v)
  2337. if ContactInfoMustReg.MatchString(thisTdVals_v) {
  2338. jumpNextTd = true
  2339. thisTrHasMatch = true
  2340. tr.TDs[td_index+1].SortKV.AddKey(myContactType+thisTdVals_v, nextTdVals[thisTdVals_k])
  2341. }
  2342. }
  2343. }
  2344. }
  2345. }
  2346. } else {
  2347. jumpNextTd = false
  2348. }
  2349. ///////////////////////////////////////
  2350. thisTdKvs := kvAfterDivideBlock(td.Text, 3)
  2351. if len(thisTdKvs) == 0 {
  2352. thisTdKvs = colonkvEntity.GetKvs(td.Text, "", 2)
  2353. }
  2354. if len(thisTdKvs) == 0 {
  2355. tdValue := regReplAllSpace.ReplaceAllString(td.Text, "")
  2356. if tdValue != "" && len([]rune(tdValue)) < 15 {
  2357. thisTdKvs = append(thisTdKvs, &u.Kv{
  2358. Key: tdValue,
  2359. Value: "",
  2360. })
  2361. }
  2362. }
  2363. tdAscFind := true
  2364. if len(thisTdKvs) == 0 {
  2365. continue
  2366. } else if allAscFind && len(thisTdKvs) >= 3 && len(indexMap) == 0 {
  2367. //采购人在联系人、电话后面的处理
  2368. isCanAddToIndexMap := false
  2369. LL:
  2370. for _, td_kv := range thisTdKvs {
  2371. //u.Debug(td_kv.PrevLine)
  2372. td_k := FilterContactKey(td_kv.Key)
  2373. td_k_length := len([]rune(td_k))
  2374. if td_k_length < 2 || td_k_length > 15 {
  2375. continue
  2376. }
  2377. isContinue := ContactInfoMustReg.MatchString(td_k)
  2378. if isContinue || (ContactInfoVagueReg.MatchString(td_k) && u.IsMapHasValue(td_k, ContactType)) {
  2379. if len(indexMap) > 0 {
  2380. indexMap = map[int]string{}
  2381. break LL
  2382. }
  2383. isCanAddToIndexMap = true
  2384. }
  2385. if isContinue {
  2386. continue
  2387. }
  2388. if len(indexMap) == 0 {
  2389. for _, k := range HasOrderContactType(td_k) {
  2390. if !ContactType[k].MatchString(td_k) {
  2391. continue
  2392. }
  2393. if isCanAddToIndexMap && len(indexMap) == 0 {
  2394. indexMap[0] = k
  2395. break
  2396. }
  2397. }
  2398. }
  2399. }
  2400. if len(indexMap) > 0 {
  2401. tdAscFind = false
  2402. }
  2403. }
  2404. prevKey := ""
  2405. oldIndexMapLength := len(indexMap)
  2406. thidTdIndex := td_index
  2407. notmatchCount := 0
  2408. kvTitle := ""
  2409. for _, td_kv := range thisTdKvs {
  2410. //u.Debug(td_kv.Key, td_kv.Value, td_kv.Title)
  2411. iscontinue := false
  2412. td_v := td_kv.Value
  2413. td_k := FilterContactKey(td_kv.Key)
  2414. td_k_length := len([]rune(td_k))
  2415. //
  2416. if allAscFind && tdAscFind {
  2417. for _, k := range HasOrderContactType(td_k) {
  2418. if td_k_length < 3 || td_k_length > 15 {
  2419. continue
  2420. }
  2421. if !ContactType[k].MatchString(td_k) {
  2422. matchCount++
  2423. continue
  2424. }
  2425. if weightMap[k] == nil {
  2426. weightMap[k] = map[string]interface{}{}
  2427. }
  2428. if ContactInfoVagueReg.MatchString(td_k) {
  2429. if matchMap[k] == nil {
  2430. matchMap[k] = map[string]bool{}
  2431. }
  2432. isAddToMatchMap := true
  2433. if !strings.HasSuffix(td_k, "方式") {
  2434. _, kTag := KvTagsToKV([]*u.Kv{&u.Kv{Key: td_k, Value: td_v}}, "", BuyerContacts, 3)
  2435. if len(kTag) == 1 {
  2436. tagVal, weightVal := u.FirstKeyValueInMap(kTag)
  2437. if tagVal == "采购单位联系人" && ContactBuyerPersonFilterReg.MatchString(td_v) {
  2438. isAddToMatchMap = false
  2439. }
  2440. if td.SortKV.Map[tagVal] != nil {
  2441. if weightMap[k][tagVal] == nil || (weightVal != nil && weightVal.(int) >= weightMap[k][tagVal].(int)) {
  2442. weightMap[k][tagVal] = weightVal.(int)
  2443. td.SortKV.AddKey(tagVal, td_v)
  2444. thisTrHasMatch = true
  2445. }
  2446. } else {
  2447. weightMap[k][tagVal] = weightVal.(int)
  2448. }
  2449. }
  2450. }
  2451. if isAddToMatchMap && !filterValue.MatchString(td_v) && td_v != "" {
  2452. matchMap[k][ContactInfoVagueReg.FindString(td_k)] = true
  2453. }
  2454. } else if k == "采购单位" { //打标签,权重高的重新覆盖
  2455. _, kTag := KvTagsToKV([]*u.Kv{td_kv}, "", []string{"采购单位"}, 3)
  2456. tagVal, weightVal := u.FirstKeyValueInMap(kTag)
  2457. if tagVal == k {
  2458. if weightMap[k][k] == nil || (weightVal != nil && weightVal.(int) >= weightMap[k][k].(int)) || len(matchMap[k]) == 0 {
  2459. weightMap[k][k] = weightVal.(int)
  2460. matchMap[k] = map[string]bool{}
  2461. indexMap = map[int]string{}
  2462. }
  2463. }
  2464. }
  2465. if u.IsMapHasValue(k, indexMap) {
  2466. thisTrHasMatch = true
  2467. iscontinue = true
  2468. continue
  2469. }
  2470. if reCreate {
  2471. indexMap = map[int]string{}
  2472. reCreate = false
  2473. }
  2474. indexMap[thidTdIndex] = k
  2475. iscontinue = true
  2476. thisTrHasMatch = true
  2477. thidTdIndex++
  2478. break
  2479. }
  2480. if len(indexMap) == 0 {
  2481. prevLine := FilterSerial.ReplaceAllString(td_kv.PrevLine, "")
  2482. for k, v := range ContactType {
  2483. if u.IsArrayHasValue(prevLine, v.FindAllString(prevLine, -1)) {
  2484. indexMap[thidTdIndex] = k
  2485. thisTrHasMatch = true
  2486. thidTdIndex++
  2487. }
  2488. }
  2489. }
  2490. if len(indexMap) == 0 {
  2491. if titleMatchType := ContactTypeTitleMatch(td_kv.Title); titleMatchType != "" {
  2492. thidTdIndex = 0
  2493. matchMap = map[string]map[string]bool{}
  2494. indexMap = map[int]string{1: titleMatchType}
  2495. }
  2496. }
  2497. }
  2498. if iscontinue {
  2499. continue
  2500. }
  2501. //不在同一块中
  2502. if td_kv.Title != "" && kvTitle != td_kv.Title && len(indexMap) > 0 && !ContactInfoMustReg.MatchString(td_kv.Key) {
  2503. thidTdIndex = 0
  2504. matchMap = map[string]map[string]bool{}
  2505. indexMap = map[int]string{}
  2506. }
  2507. kvTitle = td_kv.Title
  2508. //u.Debug(indexMap, td_k, td_v, matchMap)
  2509. if len(indexMap) > 0 {
  2510. if td_k_length < 2 || td_k_length > 10 {
  2511. continue
  2512. }
  2513. modle := 0
  2514. if len(thisTdKvs) == 1 {
  2515. if regReplAllSpace.ReplaceAllString(thisTdKvs[0].Value, "") == "" {
  2516. modle = 1
  2517. } else {
  2518. modle = 2
  2519. }
  2520. }
  2521. if !ContactInfoMustReg.MatchString(td_k) {
  2522. notmatchCount++
  2523. if notmatchCount < len(indexMap)*2 && false {
  2524. notmatchCount = 0
  2525. thidTdIndex = 0
  2526. indexMap = map[int]string{}
  2527. matchMap = map[string]map[string]bool{}
  2528. }
  2529. if mustMatchFirst {
  2530. break L
  2531. }
  2532. continue
  2533. }
  2534. reCreate = true
  2535. index := td_index
  2536. if oldIndexMapLength == 0 && len(indexMap) > 1 {
  2537. if prevKey != td_k {
  2538. prevKey = td_k
  2539. index = td_index
  2540. } else if prevKey == td_k {
  2541. index++
  2542. }
  2543. }
  2544. if filterValue.MatchString(td_v) {
  2545. thisTrHasMatch = true
  2546. continue
  2547. }
  2548. //u.Debug(indexMap, td_k, td_v, matchMap, index, modle)
  2549. myContactType := indexMap[index]
  2550. if myContactType == "" && len(indexMap) == 1 {
  2551. _, onlyContactType := u.FirstKeyValueInMap(indexMap)
  2552. myContactType, _ = onlyContactType.(string)
  2553. }
  2554. if myContactType == "" {
  2555. continue
  2556. }
  2557. matchCount++
  2558. if matchMap[myContactType] == nil {
  2559. matchMap[myContactType] = map[string]bool{}
  2560. }
  2561. if IsContactKvHandle(ContactInfoMustReg.FindString(td_k), matchMap[myContactType]) {
  2562. continue
  2563. }
  2564. matchMap[myContactType][ContactInfoMustReg.FindString(td_k)] = true
  2565. if ContactType[myContactType].MatchString(td_k) {
  2566. continue
  2567. }
  2568. thisTrHasMatch = true
  2569. if modle == 1 {
  2570. td.Text = myContactType + td_k
  2571. td.Val = td.Text
  2572. } else {
  2573. //
  2574. if !strings.HasSuffix(td_k, "方式") {
  2575. _, kTag := KvTagsToKV([]*u.Kv{&u.Kv{Key: myContactType + td_k, Value: td_v}}, "", BuyerContacts, 3)
  2576. if len(kTag) == 1 {
  2577. tagVal, _ := u.FirstKeyValueInMap(kTag)
  2578. if tagVal == "采购单位联系人" && ContactBuyerPersonFilterReg.MatchString(td_v) {
  2579. continue
  2580. }
  2581. if contactTypeTagMap[myContactType] == nil {
  2582. contactTypeTagMap[myContactType] = map[string][]interface{}{}
  2583. }
  2584. myOldKeyArray := contactTypeTagMap[myContactType][tagVal]
  2585. if myOldKeyArray != nil {
  2586. tn.TRs[myOldKeyArray[0].(int)].TDs[myOldKeyArray[1].(int)].SortKV.RemoveKey(myContactType + myOldKeyArray[2].(string))
  2587. } else {
  2588. contactTypeTagMap[myContactType][tagVal] = make([]interface{}, 3)
  2589. }
  2590. if weightMap[myContactType] == nil {
  2591. weightMap[myContactType] = map[string]interface{}{}
  2592. }
  2593. weightMap[myContactType][tagVal] = 1
  2594. contactTypeTagMap[myContactType][tagVal] = []interface{}{tr_index, td_index, td_k}
  2595. }
  2596. }
  2597. td.SortKV.AddKey(myContactType+td_k, td_v)
  2598. }
  2599. }
  2600. }
  2601. //u.Debug(td.SortKV.Map)
  2602. }
  2603. if allAscFind && !thisTrHasMatch {
  2604. notMatchTrCount++
  2605. if notMatchTrCount >= 2 {
  2606. notMatchTrCount = 0
  2607. indexMap = map[int]string{}
  2608. }
  2609. }
  2610. }
  2611. //u.Debug("end", matchCount, indexMap, matchMap)
  2612. if matchCount == 0 {
  2613. indexMap = map[int]string{}
  2614. matchMap = map[string]map[string]bool{}
  2615. }
  2616. (*contactFormat).IndexMap = indexMap
  2617. (*contactFormat).MatchMap = matchMap
  2618. // for _, tr := range tn.TRs {
  2619. // for _, td := range tr.TDs {
  2620. // log.Println(td.SortKV.Map)
  2621. // }
  2622. // }
  2623. }
  2624. func (table *Table) analyBrand() {
  2625. //5c2d8c05a5cb26b9b782572b
  2626. //产品名称 品牌 规格 单价 单位 数量 小计 质保期
  2627. lineMapArr := make(map[string]*SortMap)
  2628. lineMap := make(map[string]*SortMap)
  2629. brandRule := u.BrandRules
  2630. //将val为数组和string的分开
  2631. for _, key := range table.SortKV.Keys { //遍历table.SortKV.Keys而不是直接遍历table.SortKV.Map是为了得到table头的顺序
  2632. val := table.SortKV.Map[key]
  2633. key = regReplAllSpace.ReplaceAllString(key, "")
  2634. key = strings.Replace(key, "", "", -1) //处理一个特殊的采购量 经上层处理空格后未处理掉
  2635. if realTypeVal, ok := val.([]string); ok { //val为数组 {"数量":["1","2","3"]}
  2636. /*
  2637. {
  2638. "商品":["",""],
  2639. "商品_"["",""],
  2640. }
  2641. */
  2642. valArr, allempty := filterVal(realTypeVal...) //过滤数据
  2643. if allempty {
  2644. continue
  2645. }
  2646. realTypeVal = valArr
  2647. line := underline.FindString(key)
  2648. lineValMap1 := lineMapArr[line]
  2649. // i := 1
  2650. // L:
  2651. // for { //去除数组空数据
  2652. // last := realTypeVal[len(realTypeVal)-i]
  2653. // if last == "" {
  2654. // i++
  2655. // if i > len(realTypeVal) {
  2656. // break
  2657. // }
  2658. // goto L
  2659. // } else {
  2660. // break
  2661. // }
  2662. // }
  2663. // dislodgeNull := realTypeVal[:(len(realTypeVal) - i + 1)] //去除数组中空数据
  2664. if len(realTypeVal) > 0 {
  2665. if lineValMap1 == nil {
  2666. tmp := NewSortMap()
  2667. tmp.AddKey(key, realTypeVal)
  2668. lineMapArr[line] = tmp
  2669. } else {
  2670. lineValMap1.AddKey(key, realTypeVal)
  2671. }
  2672. }
  2673. //qutil.Debug("lineMapArr---", lineMapArr[line].Keys, lineMapArr[line].Map)
  2674. } else if realTypeVal, b := val.(string); b { //val为字符串 {"数量":"1"}
  2675. /*
  2676. {
  2677. "商品:"",名称:"",
  2678. "商品_:"",名称_:"",
  2679. "商品__:"",名称__:"",
  2680. }
  2681. */
  2682. valArr, allempty := filterVal(realTypeVal) //过滤数据
  2683. if allempty {
  2684. continue
  2685. }
  2686. realTypeVal = valArr[0]
  2687. line := underline.FindString(key)
  2688. lineValMap2 := lineMap[line]
  2689. if lineValMap2 == nil {
  2690. tmp := NewSortMap()
  2691. tmp.AddKey(key, realTypeVal)
  2692. lineMap[line] = tmp
  2693. } else {
  2694. lineValMap2.AddKey(key, realTypeVal)
  2695. }
  2696. //qutil.Debug("lineMap---", lineMap[line].Keys, lineMap[line].Map)
  2697. } else {
  2698. // "_id" : ObjectId("5c2c3802a5cb26b9b78646c4")5c2b0551a5cb26b9b7cb05db否5c2a42e6a5cb26b9b763ba5a采购人:一、采购人5c2b06f5a5cb26b9b7cc4409
  2699. //成交供应商排名 [map[entname:昆明合优科技有限公司 sortstr:第一中标候选人 sort:1] map[sort:2 entname:昆明厚起科技有限公司 sortstr:第二中标候选人] map[entname:云南远安科技发展有限公司 sortstr:第三中标候选人 sort:3]]
  2700. //fmt.Println("err data:", key, val)
  2701. }
  2702. }
  2703. //处理数组数据后,匹配必须title和替换要保存的title
  2704. //qutil.Debug("lineMapArr----", len(lineMapArr))
  2705. if len(lineMapArr) > 0 {
  2706. for _, aMap := range lineMapArr {
  2707. maxNum := 0
  2708. arrcount1 := 0 //记录key是否存在必须title(数组数据)
  2709. arrcount2 := 0
  2710. ka := make(map[string][]string) //最终存储数据
  2711. //qutil.Debug("aMap.Keys----", aMap.Keys)
  2712. for _, k0 := range aMap.Keys {
  2713. match := false //记录must是否匹配到
  2714. v0 := aMap.Map[k0].([]string)
  2715. //匹配必须title
  2716. for nameM, r := range brandRule["must"] {
  2717. if convert(k0, r) { //匹配成功
  2718. v0tmp1 := v0
  2719. match = true
  2720. if len(ka[nameM]) != 0 && strings.Contains(k0, "描述") { //防止k0匹配到多次 和特殊情况 物料名称 物料描述同时出现
  2721. continue
  2722. }
  2723. if nameM == "itemname" || nameM == "modal" {
  2724. hasGoods(table, v0...) //判断itemname和modal中有没有商品
  2725. if nameM == "itemname" {
  2726. v0tmp1 = filterItem(v0...) //过滤itemname
  2727. }
  2728. }
  2729. if nameM == "brandname" || nameM == "modal" {
  2730. if len(ka["brandname"]) == 0 {
  2731. brand, allNull := hasBrand(table, v0...)
  2732. if !allNull {
  2733. ka["brandname"] = brand
  2734. }
  2735. }
  2736. }
  2737. //unitprice
  2738. if nameM == "unitprice" { //处理金额
  2739. v0tmp1 = dealPrice(k0, v0...)
  2740. }
  2741. if nameM != "brandname" && len(ka[nameM]) == 0 {
  2742. ka[nameM] = v0tmp1
  2743. }
  2744. arrcount1++
  2745. }
  2746. }
  2747. //替换其它要保存字段
  2748. if !match { //must未匹配,匹配replace
  2749. for nameR, r := range brandRule["replace"] {
  2750. if convert(k0, r) { //匹配成功
  2751. v0tmp2 := v0
  2752. //totalprice
  2753. if nameR == "totalprice" { //处理金额
  2754. v0tmp2 = dealPrice(k0, v0...)
  2755. }
  2756. //number
  2757. if nameR == "number" { //处理数量
  2758. uname0 := []string{}
  2759. v0tmp2, uname0 = dealNumber(v0...)
  2760. if len(ka["unitname"]) == 0 && len(uname0) != 0 {
  2761. ka["unitname"] = uname0
  2762. }
  2763. }
  2764. if len(v0tmp2) > 0 {
  2765. ka[nameR] = v0tmp2
  2766. }
  2767. arrcount2++
  2768. }
  2769. }
  2770. }
  2771. }
  2772. //找最终存储数据的最小len(arr)
  2773. // for _, vf := range ka {
  2774. // //找最短的数组
  2775. // lenVal := len(vf)
  2776. // if minNum == 0 || minNum > lenVal { //maxNum = len(最短数组)
  2777. // minNum = lenVal
  2778. // }
  2779. // }
  2780. //找最终存储数据的最大len(arr),小的补空
  2781. for _, vf1 := range ka {
  2782. lenVal := len(vf1)
  2783. if lenVal > maxNum {
  2784. maxNum = lenVal
  2785. }
  2786. }
  2787. finishKa := make(map[string][]string)
  2788. for vf2K, vf2 := range ka {
  2789. if len(vf2) < maxNum {
  2790. lenMv := maxNum - len(vf2)
  2791. for i := 0; i < lenMv; i++ {
  2792. vf2 = append(vf2, "")
  2793. }
  2794. }
  2795. finishKa[vf2K] = vf2
  2796. }
  2797. hasKey(table, arrcount1) //是否匹配到table中的标题
  2798. //qutil.Debug("finishKa----", finishKa)
  2799. if arrcount1 >= 1 {
  2800. if arrcount1+arrcount2 == 1 { //删除只匹配到一个价钱(总价)
  2801. delete(finishKa, "unitprice")
  2802. }
  2803. finishData := dealArrData(maxNum, finishKa)
  2804. table.BrandData = append(table.BrandData, finishData)
  2805. }
  2806. }
  2807. }
  2808. //处理string数据后,匹配必须title和替换要保存的title
  2809. //qutil.Debug("lineMap----", len(lineMap))
  2810. if len(lineMap) > 0 {
  2811. for _, sMap := range lineMap {
  2812. strcount1 := 0 //记录key是否存在必须title(字符串数据)
  2813. strcount2 := 0
  2814. endStrMap := make(map[string]string)
  2815. //qutil.Debug(k, "aMap.Keys----", sMap.Keys)
  2816. for _, k1 := range sMap.Keys {
  2817. match := false //记录must是否匹配到
  2818. v1 := qutil.ObjToString(sMap.Map[k1])
  2819. // for k1, v1 := range sMap {
  2820. //qutil.Debug(k1, "++++++++++", v1)
  2821. if v1 == "" {
  2822. continue
  2823. }
  2824. //匹配必须title
  2825. for nameM, r := range brandRule["must"] {
  2826. if convert(k1, r) { //匹配成功
  2827. v1tmp1 := v1
  2828. match = true
  2829. if nameM == "itemname" || nameM == "modal" { //特殊处理itemname
  2830. hasGoods(table, v1)
  2831. if nameM == "itemname" {
  2832. v1tmp1 = filterItem(v1)[0] //过滤itemname
  2833. if v1tmp1 == "" {
  2834. break
  2835. }
  2836. }
  2837. }
  2838. if nameM == "brandname" || nameM == "modal" { //特殊处理brandname
  2839. if endStrMap["brandname"] == "" {
  2840. brand, allNull := hasBrand(table, v1)
  2841. if !allNull {
  2842. endStrMap["brandname"] = brand[0]
  2843. }
  2844. }
  2845. }
  2846. //unitprice
  2847. if nameM == "unitprice" { //处理金额
  2848. v1tmp1 = dealPrice(k1, v1)[0]
  2849. }
  2850. if nameM != "brandname" && endStrMap[nameM] == "" {
  2851. endStrMap[nameM] = v1tmp1
  2852. }
  2853. strcount1++
  2854. }
  2855. }
  2856. //替换其它要保存字段
  2857. if !match {
  2858. for nameR, r := range brandRule["replace"] {
  2859. if convert(k1, r) { //匹配成功
  2860. v1tmp2 := v1
  2861. //totalprice
  2862. if nameR == "totalprice" { //处理金额
  2863. v1tmp2 = dealPrice(k1, v1)[0]
  2864. }
  2865. //number
  2866. if nameR == "number" { //处理数量
  2867. varr1, uname1 := dealNumber(v1)
  2868. v1tmp2 = varr1[0]
  2869. //从number中获取到的单位
  2870. if endStrMap["unitname"] == "" && uname1[0] != "" {
  2871. endStrMap["unitname"] = uname1[0]
  2872. }
  2873. }
  2874. if v1tmp2 != "" {
  2875. endStrMap[nameR] = v1tmp2
  2876. }
  2877. strcount2++
  2878. }
  2879. }
  2880. }
  2881. //}
  2882. }
  2883. //原始字符串数据处理
  2884. hasKey(table, strcount1) //是否匹配到table中的标题
  2885. //qutil.Debug("endStrMap----", endStrMap)
  2886. if strcount1 >= 1 {
  2887. if strcount1+strcount2 == 1 { //删除只匹配到一个价钱(总价)
  2888. delete(endStrMap, "unitprice")
  2889. }
  2890. finishData := dealStrData(endStrMap) //处理数据
  2891. if len(finishData) > 0 {
  2892. table.BrandData = append(table.BrandData, finishData)
  2893. }
  2894. }
  2895. }
  2896. }
  2897. }
  2898. func dealArrData(maxNum int, ka map[string][]string) []map[string]string {
  2899. for k2, v2 := range ka {
  2900. //处理数组长度不相等,使长度一致
  2901. if len(v2) > maxNum {
  2902. ka[k2] = v2[:maxNum]
  2903. }
  2904. }
  2905. finalData := assembleData(ka, 1)
  2906. if len(finalData) > 0 {
  2907. return finalData
  2908. }
  2909. return nil
  2910. }
  2911. func dealStrData(kv map[string]string) []map[string]string {
  2912. finalData := []map[string]string{}
  2913. if len(kv) > 0 {
  2914. finalData = assembleData(kv, 2)
  2915. }
  2916. return finalData
  2917. }
  2918. //组装数据,每一行的数据为一数据集合
  2919. func assembleData(m interface{}, n int) []map[string]string {
  2920. defer qutil.Catch()
  2921. /*
  2922. {
  2923. "itemname":["计算机","打印机","机柜"],
  2924. "number" :["1","12","4"]
  2925. }
  2926. */
  2927. datas := []map[string]string{}
  2928. if n == 1 { //数组数据
  2929. realTypeM := m.(map[string][]string)
  2930. //根据数组数据的顺序 将多个数组中索引相同的数据拼装成一个map,并将这多个map放入一个arr
  2931. /*
  2932. arr1 ["a1","b1","c1"]
  2933. arr2 ["a2","b2","c2"]
  2934. [
  2935. {"a1","a2"},
  2936. {"b1","b2"},
  2937. {"c1","c2"}
  2938. ]
  2939. */
  2940. //start
  2941. for k3, v3 := range realTypeM {
  2942. for _, val := range v3 {
  2943. data := make(map[string]string)
  2944. data[k3] = val
  2945. datas = append(datas, data)
  2946. }
  2947. break
  2948. }
  2949. for i, data := range datas {
  2950. for k4, v4 := range realTypeM {
  2951. if i < len(v4) { //数组数据长度不一致
  2952. if v4[i] != " " {
  2953. data[k4] = v4[i]
  2954. } else {
  2955. delete(data, k4)
  2956. }
  2957. } else {
  2958. fmt.Println("err table")
  2959. }
  2960. }
  2961. datas[i] = data
  2962. }
  2963. //end
  2964. for _, fdv := range datas { //清除空数据和只含特殊符号的数据
  2965. for fmk, fmv := range fdv {
  2966. if tabletdclear.ReplaceAllString(fmv, "") == "" {
  2967. delete(fdv, fmk)
  2968. }
  2969. }
  2970. }
  2971. } else { //字符串数据
  2972. realTypeM := m.(map[string]string)
  2973. datas = append(datas, realTypeM)
  2974. }
  2975. return datas
  2976. }
  2977. ////组装数据,每一行的数据为一数据集合
  2978. //func assembleData(m interface{}, n int) []map[string]string {
  2979. // defer qutil.Catch()
  2980. // /*
  2981. // {
  2982. // "itemname":["计算机","打印机","机柜"],
  2983. // "number" :["1","12","4"]
  2984. // }
  2985. // */
  2986. // datas := []map[string]string{}
  2987. // switch reflect.TypeOf(m).String() {
  2988. // case "map[string][]string": //数组数据
  2989. // realTypeM := m.(map[string][]string)
  2990. // //根据数组数据的顺序 将多个数组中索引相同的数据拼装成一个map,并将这多个map放入一个arr
  2991. // /*
  2992. // arr1 ["a1","b1","c1"]
  2993. // arr2 ["a2","b2","c2"]
  2994. // [
  2995. // {"a1","a2"},
  2996. // {"b1","b2"},
  2997. // {"c1","c2"}
  2998. // ]
  2999. // */
  3000. // //start
  3001. // for k3, v3 := range realTypeM {
  3002. // for _, val := range v3 {
  3003. // data := make(map[string]string)
  3004. // data[k3] = val
  3005. // datas = append(datas, data)
  3006. // }
  3007. // break
  3008. // }
  3009. // for i, data := range datas {
  3010. // for k4, v4 := range realTypeM {
  3011. // if i < len(v4) { //数组数据长度不一致
  3012. // if v4[i] != " " {
  3013. // data[k4] = v4[i]
  3014. // } else {
  3015. // delete(data, k4)
  3016. // //continue
  3017. // }
  3018. // } else {
  3019. // fmt.Println("err table")
  3020. // //continue
  3021. // }
  3022. // }
  3023. // datas[i] = data
  3024. // }
  3025. // //end
  3026. // // for _, fdv := range datas { //清除空数据和只含特殊符号的数据
  3027. // // for fmk, fmv := range fdv {
  3028. // // if tabletdclear.ReplaceAllString(fmv, "") == "" {
  3029. // // delete(fdv, fmk)
  3030. // // }
  3031. // // }
  3032. // // }
  3033. // case "map[string]string": //字符串数据
  3034. // realTypeM := m.(map[string]string)
  3035. // datas = append(datas, realTypeM)
  3036. // default:
  3037. // }
  3038. // return datas
  3039. //}
  3040. func convert(key, r string) bool {
  3041. defer qutil.Catch()
  3042. flag := false
  3043. key = tabletitleclear.ReplaceAllString(key, "")
  3044. reg, err := regexp.Compile(r)
  3045. if err != nil {
  3046. fmt.Println("reg err:", err)
  3047. return false
  3048. }
  3049. flag = reg.MatchString(key)
  3050. return flag
  3051. }
  3052. func hasKey(table *Table, n int) {
  3053. defer qutil.Catch()
  3054. if table.TableResult.HasKey == 1 {
  3055. return
  3056. }
  3057. if n >= 1 {
  3058. table.TableResult.HasKey = 1
  3059. }
  3060. }
  3061. func hasGoods(table *Table, data ...string) {
  3062. defer qutil.Catch()
  3063. goodsArr := make([]string, len(data))
  3064. //fmt.Println("table.TableResult.HasGoods=====", table.TableResult.HasGoods)
  3065. if table.TableResult.HasGoods == 1 {
  3066. return
  3067. }
  3068. for i, d := range data {
  3069. if d != "" {
  3070. goods := u.GoodsGet.CheckSensitiveWord(d)
  3071. //fmt.Println("goods======", goods)
  3072. goodsArr[i] = goods
  3073. if len(goods) > 0 {
  3074. table.TableResult.HasGoods = 1
  3075. break
  3076. }
  3077. }
  3078. }
  3079. }
  3080. //func hasBrand(table *Table, data ...string) {
  3081. // defer qutil.Catch()
  3082. // if table.TableResult.HasBrand == 1 {
  3083. // return
  3084. // }
  3085. // for i, d := range data {
  3086. // if d != "" {
  3087. // brand := u.BrandGet.CheckSensitiveWord(d)
  3088. // qutil.Debug(d, brand)
  3089. // if brand != "" {
  3090. // table.TableResult.HasBrand = 1
  3091. // break
  3092. // }
  3093. // }
  3094. // }
  3095. //}
  3096. func hasBrand(table *Table, data ...string) ([]string, bool) {
  3097. defer qutil.Catch()
  3098. //fmt.Println("table.TableResult.HasBrand---------", table.TableResult.HasBrand)
  3099. brandArr := make([]string, len(data))
  3100. // if table.TableResult.HasBrand == 1 {
  3101. // return brandArr, 1
  3102. // }
  3103. allNull := true
  3104. for i, d := range data {
  3105. //if d != "" {
  3106. brand := u.BrandGet.CheckSensitiveWord(d)
  3107. if brand != "" {
  3108. allNull = false
  3109. }
  3110. //fmt.Println("brand======", brand)
  3111. brandArr[i] = brand
  3112. if len(brand) > 0 {
  3113. table.TableResult.HasBrand = 1
  3114. }
  3115. //}
  3116. }
  3117. return brandArr, allNull
  3118. }
  3119. //过滤td值
  3120. func filterVal(val ...string) ([]string, bool) {
  3121. defer qutil.Catch()
  3122. n := 0 //记录被过滤的个数
  3123. for i, v := range val {
  3124. afterFilter := tabletdclear.ReplaceAllString(v, "")
  3125. afterFilter = NullVal.ReplaceAllString(afterFilter, "")
  3126. if afterFilter == "" {
  3127. n++
  3128. }
  3129. val[i] = afterFilter
  3130. }
  3131. allempty := false
  3132. if n == len(val) { //所有都被过滤掉
  3133. allempty = true
  3134. }
  3135. return val, allempty
  3136. }
  3137. //过滤itemname全是数字
  3138. func filterItem(itemval ...string) []string {
  3139. defer qutil.Catch()
  3140. result := []string{}
  3141. for _, v := range itemval {
  3142. afterFilter := numclear.ReplaceAllString(v, "")
  3143. if afterFilter != "" {
  3144. result = append(result, v)
  3145. } else {
  3146. result = append(result, afterFilter)
  3147. }
  3148. }
  3149. return result
  3150. }
  3151. //处理价格
  3152. func dealPrice(key string, val ...string) []string {
  3153. defer qutil.Catch()
  3154. iswan := strings.Contains(key, "万") //表格title中带有万
  3155. result := []string{}
  3156. for _, v := range val { //1.00万元 1元
  3157. tmparr := strings.Split(v, ".")
  3158. tmparr[0] = moneyNum.ReplaceAllString(tmparr[0], "")
  3159. if iswan {
  3160. result = append(result, tmparr[0]+"0000")
  3161. } else {
  3162. if strings.Contains(v, "万") { //价格中带有万
  3163. result = append(result, tmparr[0]+"0000")
  3164. } else {
  3165. result = append(result, tmparr[0])
  3166. }
  3167. }
  3168. }
  3169. return result
  3170. }
  3171. //处理number
  3172. func dealNumber(val ...string) ([]string, []string) {
  3173. defer qutil.Catch()
  3174. unitnameArr := []string{}
  3175. result := []string{}
  3176. for _, v := range val { //1个 1.00个
  3177. n := numclear.FindString(v)
  3178. unitname := numclear.ReplaceAllString(v, "") //匹配个数后的单位
  3179. unitnameArr = append(unitnameArr, unitname)
  3180. //val[i] = strings.Split(n, ".")[0]
  3181. result = append(result, strings.Split(n, ".")[0])
  3182. }
  3183. return result, unitnameArr
  3184. }