jy-data-extract/src/jy/extract/extract.go

package extract

import (
	"encoding/json"
	//"encoding/json"
	"fmt"
	"jy/clear"
	db "jy/mongodbutil"
	"jy/pretreated"
	ju "jy/util"
	"log"
	qu "qfw/util"
	"regexp"
	"strconv"
	"strings"
	"sync"
	"time"

	"gopkg.in/mgo.v2/bson"
)

var (
	lock      sync.RWMutex
	cut       = ju.NewCut()                          //获取正文并清理
	ExtLogs   map[*TaskInfo][]map[string]interface{} //抽取日志
	TaskList  map[string]*ExtractTask                //任务列表
	saveLimit = 200                                  //抽取日志批量保存

	Fields = `{"title":1,"detail":1,"contenthtml":1,"href":1,"site":1,"spidercode":1,"toptype":1,"area":1,"city":1}`
)

//启动测试抽取
func StartExtractTestTask(taskId, startId, num, resultcoll, trackcoll string) bool {
	defer qu.Catch()
	ext := &ExtractTask{}
	ext.Id = taskId
	ext.IsRun = true
	ext.InitTestTaskInfo(resultcoll, trackcoll)
	ext.TaskInfo.DB = db.MgoFactory(1, 3, 120, ext.TaskInfo.FromDbAddr, ext.TaskInfo.FromDB)
	ext.InitRulePres()
	ext.InitRuleBacks()
	ext.InitRuleCore()
	ext.InitTag()
	ext.InitClearFn()

	ext.InitProvince()
	ext.InitCityAll()
	ext.InitCitySim()
	InitDFA()

	return RunExtractTestTask(ext, startId, num)
}

func IdTrans(startId string) bson.ObjectId {
	defer qu.Catch()
	return bson.ObjectIdHex(startId)
}

//开始测试任务抽取
func RunExtractTestTask(ext *ExtractTask, startId, num string) bool {
	n, _ := strconv.Atoi(num)
	id := IdTrans(startId)
	if id.Valid() {
		query := bson.M{"_id": bson.M{"$gte": bson.ObjectIdHex(startId)}}
		list, _ := ext.TaskInfo.DB.Find(ext.TaskInfo.FromColl, query, nil, Fields, false, 0, n)
		for _, v := range *list {
			j := PreInfo(v)
			ext.TaskInfo.ProcessPool <- true
			go ext.ExtractProcess(j)
		}
		return true
	} else {
		return false
	}
}

//启动抽取
func StartExtractTaskId(taskId string) bool {
	isgo := false
	ext := TaskList[taskId]
	if ext == nil {
		ext = &ExtractTask{}
		ext.Id = taskId
		ext.InitTaskInfo()
		isgo = true
	} else {
		ext.Id = taskId
		ext.InitTaskInfo()
	}
	ext.TaskInfo.DB = db.MgoFactory(1, 3, 120, ext.TaskInfo.FromDbAddr, ext.TaskInfo.FromDB)
	ext.InitRulePres()
	ext.InitRuleBacks()
	ext.InitRuleCore()
	ext.InitTag()
	ext.InitClearFn()

	ext.InitProvince()
	ext.InitCityAll()
	ext.InitCitySim()
	InitDFA()

	ext.IsRun = true
	if isgo {
		go RunExtractTask(taskId)
	}
	TaskList[taskId] = ext
	return true
}

//停止抽取
func StopExtractTaskId(taskId string) bool {
	ext := TaskList[taskId]
	if ext != nil {
		ext.IsRun = false
		TaskList[taskId] = ext
	}
	//更新task.s_extlastid
	db.Mgo.UpdateById("task", taskId, `{"$set":{"s_extlastid":"`+ext.TaskInfo.LastExtId+`"}}`)
	return true
}

//开始抽取
func RunExtractTask(taskId string) {
	ext := TaskList[taskId]
	query := bson.M{"_id": bson.M{"$gte": bson.ObjectIdHex(ext.TaskInfo.LastExtId)}}
	list, _ := ext.TaskInfo.DB.Find(ext.TaskInfo.FromColl, query, nil, Fields, false, -1, -1)
	for k, v := range *list {
		log.Println(k, v["_id"])
		if !ext.IsRun {
			break
		}
		j := PreInfo(v)
		ext.TaskInfo.ProcessPool <- true
		go ext.ExtractProcess(j)
		ext.TaskInfo.LastExtId = qu.BsonIdToSId(v["_id"])
	}
	//更新task.s_extlastid
	db.Mgo.UpdateById("task", ext.Id, `{"$set":{"s_extlastid":"`+ext.TaskInfo.LastExtId+`"}}`)
	time.AfterFunc(1*time.Minute, func() { RunExtractTask(taskId) })
}

//信息预处理
func PreInfo(doc map[string]interface{}) *ju.Job {
	detail := ""
	d1, _ := doc["detail"].(string)
	d2, _ := doc["contenthtml"].(string)
	if len(d1) >= len(d2) || d2 == "" {
		detail = d1
	} else {
		detail = d2
	}
	detail = ju.CutLableStr(detail)
	detail = cut.ClearHtml(detail)
	doc["detail"] = detail
	href := qu.ObjToString(doc["href"])
	if strings.HasPrefix(href, "http://") {
		href = href[7:]
	} else if strings.HasPrefix(href, "https://") {
		href = href[8:]
	}
	pos := strings.Index(href, "/")
	if pos > 0 {
		href = href[:pos]
	}
	doc["domain"] = href
	toptype := qu.ObjToString(doc["toptype"])
	if qu.ObjToString(doc["type"]) == "bid" {
		toptype = "结果"
	}
	if toptype == "" {
		toptype = "*"
	}
	j := &ju.Job{
		SourceMid:  qu.BsonIdToSId(doc["_id"]),
		Category:   toptype,
		Content:    qu.ObjToString(doc["detail"]),
		SpiderCode: qu.ObjToString(doc["spidercode"]),
		Domain:     qu.ObjToString(doc["domain"]),
		Href:       qu.ObjToString(doc["href"]),
		Title:      qu.ObjToString(doc["title"]),
		Data:       &doc,
		City:       qu.ObjToString(doc["city"]),
		Province:   qu.ObjToString(doc["area"]),
		Result:     map[string][]*ju.ExtField{},
		BuyerAddr:  qu.ObjToString(doc["buyeraddr"]),
	}
	pretreated.AnalyStart(j)
	return j
}

//抽取
func (e *ExtractTask) ExtractProcess(j *ju.Job) {
	qu.Catch()
	qu.Try(func() {
		doc := *j.Data
		//全局前置规则,结果覆盖doc属性
		for _, v := range e.RulePres {
			doc = ExtRegPre(doc, j, v, e.TaskInfo)
		}
		//log.Println("全局前置规则", doc)

		//抽取规则
		for _, vc := range e.RuleCores {
			tmp := ju.DeepCopy(doc).(map[string]interface{})
			//是否进入逻辑
			if !ju.Logic(vc.LuaLogic, tmp) {
				continue
			}
			//抽取-前置规则
			for _, v := range vc.RulePres {
				tmp = ExtRegPre(tmp, j, v, e.TaskInfo)
			}
			//log.Println("抽取-前置规则", tmp)

			//抽取-规则
			for _, v := range vc.RuleCores {
				ExtRegCore(vc.ExtFrom, tmp, j, v, e)
			}
			//log.Println("抽取-规则", tmp)

			//抽取-后置规则
			for _, v := range vc.RuleBacks {
				ExtRegBack(j, v, e.TaskInfo)
			}
			//log.Println("抽取-后置规则", tmp)

		}
		//全局后置规则
		for _, v := range e.RuleBacks {
			ExtRegBack(j, v, e.TaskInfo)
		}
		//函数清理
		for key, val := range j.Result {
			for _, v := range val {
				data := clear.DoClearFn(e.ClearFn[key], []interface{}{v.Value, j.Content})
				v.Value = data[0]
			}
		}
		bs, _ := json.Marshal(j.Result)
		log.Println("抽取结果", j.Title, j.SourceMid, string(bs))
		//分析抽取结果并保存 todo
		AnalysisSaveResult(j.Data, j.Result, e.TaskInfo)

	}, func(err interface{}) {
		log.Println(err)
		<-e.TaskInfo.ProcessPool
	})
	<-e.TaskInfo.ProcessPool
}

//前置过滤
func ExtRegPre(doc map[string]interface{}, j *ju.Job, in *RegLuaInfo, t *TaskInfo) map[string]interface{} {
	before := ju.DeepCopy(doc).(map[string]interface{})
	extinfo := map[string]interface{}{}
	if in.IsLua {
		lua := ju.LuaScript{Code: in.Code, Name: in.Name, Doc: doc, Script: in.RuleText}
		if j != nil {
			lua.Block = j.Block
		}
		extinfo = lua.RunScript("pre")
		for k, v := range extinfo { //结果覆盖原doc
			doc[k] = v
		}
		AddExtLog("prereplace", j.SourceMid, before, extinfo, in, t) //抽取日志
	} else {
		key := qu.If(in.Field == "", "detail", in.Field).(string)
		text := qu.ObjToString(doc[key])
		extinfo[key] = in.RegPreBac.Reg.ReplaceAllString(text, "")
		doc[key] = extinfo[key]                                      //结果覆盖原doc
		AddExtLog("prereplace", j.SourceMid, before, extinfo, in, t) //抽取日志
	}
	return doc
}

//抽取-规则
func ExtRegCore(extfrom string, doc map[string]interface{}, j *ju.Job, in *RegLuaInfo, et *ExtractTask) {
	if in.IsLua {
		lua := ju.LuaScript{Code: in.Code, Name: in.Name, Doc: doc, Script: in.RuleText}
		lua.KvMap = getKvByLuaFields(extfrom, j, in, et.Tag)
		lua.Block = j.Block
		extinfo := lua.RunScript("core")
		for k, v := range extinfo {
			if k == in.Field {
				if j.Result[k] == nil {
					j.Result[k] = [](*ju.ExtField){}
				}
				if tmps, ok := v.([]map[string]interface{}); ok {
					for _, tmp := range tmps {
						j.Result[k] = append(j.Result[k],
							&ju.ExtField{k, qu.ObjToString(tmp["code"]), qu.ObjToString(tmp["code"]), qu.ObjToString(tmp["type"]), qu.ObjToString(tmp["matchtype"]), extfrom, tmp["value"]})
					}
				}
			}
		}
		if len(extinfo) > 0 {
			AddExtLog("extract", j.SourceMid, nil, extinfo, in, et.TaskInfo) //抽取日志
		}
	} else {
		//全文正则
		text := qu.ObjToString(doc[extfrom])
		if in.Field != "" {
			extinfo := extRegCoreToResult(extfrom, text, j, in)
			if len(extinfo) > 0 {
				AddExtLog("extract", j.SourceMid, nil, extinfo, in, et.TaskInfo) //抽取日志
			}
		}
	}
}

//lua脚本根据属性设置提取kv值
func getKvByLuaFields(extfrom string, j *ju.Job, in *RegLuaInfo, t map[string][]*Tag) map[string][]map[string]interface{} {
	kvmap := map[string][]map[string]interface{}{}
	for fieldname, field := range in.LFields {
		tags := t[field] //获取对应标签库
		for _, bl := range j.Block {
			//冒号kv
			if bl.ColonKV != nil {
				kvs := bl.ColonKV.Kvs
				kvs2 := bl.ColonKV.Kvs_2
				//log.Println("ColonKV1", kvs)
				//log.Println("ColonKV2", kvs2)
				for _, tag := range tags {
					for _, kv := range kvs {
						if tag.Type == "string" {
							if kv.Key == tag.Key {
								text := ju.TrimLRSpace(kv.Value, "")
								if text != "" {
									kvmap[field] = append(kvmap[field], map[string]interface{}{
										"field":     field,
										"code":      in.Code,
										"ruletext":  tag.Key,
										"extfrom":   extfrom,
										"value":     text,
										"type":      "colon1",
										"matchtype": "tag_string",
									})
								}
								break
							}
						} else if tag.Type == "regexp" {
							if tag.Reg.MatchString(kv.Key) {
								text := ju.TrimLRSpace(kv.Value, "")
								if text != "" {
									kvmap[field] = append(kvmap[field], map[string]interface{}{
										"field":     field,
										"code":      in.Code,
										"ruletext":  tag.Key,
										"extfrom":   extfrom,
										"value":     text,
										"type":      "colon1",
										"matchtype": "tag_regexp",
									})
								}
								break
							}
						}
					}
					for _, kv := range kvs2 {
						if tag.Type == "string" {
							if kv.Key == tag.Key {
								text := ju.TrimLRSpace(kv.Value, "")
								if text != "" {
									kvmap[field] = append(kvmap[field], map[string]interface{}{
										"field":     field,
										"code":      in.Code,
										"ruletext":  tag.Key,
										"extfrom":   extfrom,
										"value":     text,
										"type":      "colon2",
										"matchtype": "tag_string",
									})
								}
								break
							}
						} else if tag.Type == "regexp" {
							if tag.Reg.MatchString(kv.Key) {
								text := ju.TrimLRSpace(kv.Value, "")
								if text != "" {
									kvmap[field] = append(kvmap[field], map[string]interface{}{
										"field":     field,
										"code":      in.Code,
										"ruletext":  tag.Key,
										"extfrom":   extfrom,
										"value":     text,
										"type":      "colon2",
										"matchtype": "tag_regexp",
									})
								}
								break
							}
						}
					}
				}
			}
			//空格kv
			if bl.SpaceKV != nil {
				kvs := bl.SpaceKV.Kvs
				//log.Println("SpaceKV", kvs)
				for _, tag := range tags {
					for _, kv := range kvs {
						if tag.Type == "string" {
							if kv.Key == tag.Key {
								text := ju.TrimLRSpace(kv.Value, "")
								if text != "" {
									kvmap[field] = append(kvmap[field], map[string]interface{}{
										"field":     field,
										"code":      in.Code,
										"ruletext":  tag.Key,
										"extfrom":   extfrom,
										"value":     text,
										"type":      "space",
										"matchtype": "tag_string",
									})
								}
								break
							}
						} else if tag.Type == "regexp" {
							if tag.Reg.MatchString(kv.Key) {
								text := ju.TrimLRSpace(kv.Value, "")
								if text != "" {
									kvmap[field] = append(kvmap[field], map[string]interface{}{
										"field":     field,
										"code":      in.Code,
										"ruletext":  tag.Key,
										"extfrom":   extfrom,
										"value":     text,
										"type":      "space",
										"matchtype": "tag_regexp",
									})
								}
								break
							}
						}
					}
				}
			}
			//表格kv
			if bl.TableKV != nil {
				tkv := bl.TableKV
				//log.Println("tkv", tkv)
				for k, v := range tkv.Kv {
					if k == fieldname {
						if len(tags) > -tkv.KvIndex[fieldname] {
							kvmap[field] = append(kvmap[field], map[string]interface{}{
								"field":     field,
								"code":      in.Code,
								"ruletext":  tags[-tkv.KvIndex[fieldname]].Key,
								"extfrom":   "table",
								"value":     v,
								"type":      "table",
								"matchtype": "tag_string",
							})
						} else { //涉及其他待处理
							//log.Println(tags)
						}
					}
				}
			}
		}
	}
	return kvmap
}

//正则提取结果
func extRegCoreToResult(extfrom, text string, j *ju.Job, v *RegLuaInfo) map[string][]map[string]interface{} {
	extinfo := map[string][]map[string]interface{}{}
	if v.RegCore.Bextract { //正则是两部分的，可以直接抽取的（含下划线）
		apos := v.RegCore.Reg.FindAllStringSubmatchIndex(text, -1)
		if len(apos) > 0 {
			pos := apos[0]
			for k, p := range v.RegCore.ExtractPos {
				if len(pos) > p {
					if pos[p] == -1 || pos[p+1] == -1 {
						continue
					}
					val := text[pos[p]:pos[p+1]]
					tmps := []map[string]interface{}{}
					tmp := map[string]interface{}{
						"field":     v.Field,
						"code":      v.Code,
						"ruletext":  v.RuleText,
						"extfrom":   extfrom,
						"value":     val,
						"type":      "regexp",
						"matchtype": "regcontent",
					}
					tmps = append(tmps, tmp)
					extinfo[k] = tmps
					if val != "" {
						if j.Result[v.Field] == nil {
							j.Result[k] = [](*ju.ExtField){}
						}
						j.Result[k] = append(j.Result[k], &ju.ExtField{k, v.Code, v.RuleText, "regexp", "regcontent", extfrom, val})
					}
				}
			}
		}
	} else {
		pos := v.RegCore.Reg.FindStringIndex(text)
		val := ""
		if len(pos) == 2 {
			text = text[pos[1]:]
			rs := regexp.MustCompile("[^\r\n\t]+")
			tmp := rs.FindAllString(text, -1)
			if len(tmp) > 0 {
				val = tmp[0]
			}
		}
		if val != "" {
			tmps := []map[string]interface{}{}
			tmp := map[string]interface{}{
				"field":     v.Field,
				"code":      v.Code,
				"ruletext":  v.RuleText,
				"extfrom":   extfrom,
				"value":     val,
				"type":      "regexp",
				"matchtype": "regcontent",
			}
			tmps = append(tmps, tmp)
			extinfo[v.Field] = tmps
			if j.Result[v.Field] == nil {
				j.Result[v.Field] = [](*ju.ExtField){}
			}
			j.Result[v.Field] = append(j.Result[v.Field], &ju.ExtField{v.Field, v.Code, v.RuleText, "regexp", "regcontent", extfrom, val})
		}
	}
	return extinfo
}

//后置过滤
func ExtRegBack(j *ju.Job, in *RegLuaInfo, t *TaskInfo) {
	if in.IsLua {
		result := GetResultMapForLua(j)
		lua := ju.LuaScript{Code: in.Code, Name: in.Name, Result: result, Script: in.RuleText}
		if j != nil {
			lua.Block = j.Block
		}
		extinfo := lua.RunScript("back")
		for k, v := range extinfo {
			if tmps, ok := v.([]map[string]interface{}); ok {
				j.Result[k] = [](*ju.ExtField){}
				for _, tmp := range tmps {
					j.Result[k] = append(j.Result[k], &ju.ExtField{k, qu.ObjToString(tmp["code"]), qu.ObjToString(tmp["ruletext"]), qu.ObjToString(tmp["type"]), qu.ObjToString(tmp["matchtype"]), qu.ObjToString(tmp["extfrom"]), tmp["value"]})
				}
			}
		}
		if len(extinfo) > 0 {
			AddExtLog("clear", j.SourceMid, result, extinfo, in, t) //抽取日志
		}
	} else {
		extinfo := map[string]interface{}{}
		if in.Field != "" {
			if j.Result[in.Field] != nil {
				tmp := j.Result[in.Field]
				exts := []interface{}{}
				for k, v := range tmp {
					text := qu.ObjToString(v.Value)
					if text != "" {
						text = in.RegPreBac.Reg.ReplaceAllString(text, in.RegPreBac.Replace)
					}
					j.Result[in.Field][k].Value = text
					exts = append(exts, map[string]interface{}{
						"field":     v.Field,
						"code":      v.Code,
						"ruletext":  v.RuleText,
						"type":      v.Type,
						"matchtype": v.MatchType,
						"extfrom":   v.ExtFrom,
						"value":     text,
					})
				}
				extinfo[in.Field] = exts
				if len(extinfo) > 0 {
					AddExtLog("clear", j.SourceMid, tmp, extinfo, in, t) //抽取日志
				}
			}
		} else {
			for key, tmp := range j.Result {
				exts := []interface{}{}
				for k, v := range tmp {
					text := qu.ObjToString(v.Value)
					if text != "" {
						text = in.RegPreBac.Reg.ReplaceAllString(text, in.RegPreBac.Replace)
					}
					j.Result[key][k].Value = text
					exts = append(exts, map[string]interface{}{
						"field":     v.Field,
						"code":      v.Code,
						"ruletext":  v.RuleText,
						"type":      v.Type,
						"matchtype": v.MatchType,
						"extfrom":   v.ExtFrom,
						"value":     text,
					})
				}
				extinfo[key] = exts
			}
			if len(extinfo) > 0 {
				AddExtLog("clear", j.SourceMid, j.Result, extinfo, in, t) //抽取日志
			}
		}
	}
}

//获取抽取结果map[string][]interface{},lua脚本使用
func GetResultMapForLua(j *ju.Job) map[string][]map[string]interface{} {
	result := map[string][]map[string]interface{}{}
	for key, val := range j.Result {
		if result[key] == nil {
			result[key] = []map[string]interface{}{}
		}
		for _, v := range val {
			tmp := map[string]interface{}{
				"field":     v.Field,
				"code":      v.Code,
				"ruletext":  v.RuleText,
				"value":     v.Value,
				"type":      v.Type,
				"matchtype": v.MatchType,
				"extfrom":   v.ExtFrom,
			}
			result[key] = append(result[key], tmp)
		}
	}
	return result
}

//抽取日志
func AddExtLog(ftype, sid string, before interface{}, extinfo interface{}, v *RegLuaInfo, t *TaskInfo) {
	if !t.IsEtxLog {
		return
	}
	logdata := map[string]interface{}{
		"code":       v.Code,
		"name":       v.Name,
		"type":       ftype,
		"ruletext":   v.RuleText,
		"islua":      v.IsLua,
		"field":      v.Field,
		"version":    t.Version,
		"taskname":   t.Name,
		"before":     before,
		"extinfo":    extinfo,
		"sid":        sid,
		"comeintime": time.Now().Unix(),
	}
	lock.Lock()
	ExtLogs[t] = append(ExtLogs[t], logdata)
	lock.Unlock()
}

//保存抽取日志
func SaveExtLog() {
	tmpLogs := map[*TaskInfo][]map[string]interface{}{}
	lock.Lock()
	tmpLogs = ExtLogs
	ExtLogs = map[*TaskInfo][]map[string]interface{}{}
	lock.Unlock()
	for k, v := range tmpLogs {
		if len(v) < saveLimit {
			db.Mgo.SaveBulk(k.TrackColl, v...)
		} else {
			for {
				if len(v) > saveLimit {
					tmp := v[:saveLimit]
					db.Mgo.SaveBulk(k.TrackColl, tmp...)
					v = v[saveLimit:]
				} else {
					db.Mgo.SaveBulk(k.TrackColl, v...)
					break
				}
			}
		}
	}
	time.AfterFunc(10*time.Second, SaveExtLog)
}

type FieldValue struct {
	Value interface{}
	Count int
}

//分析抽取结果并保存
func AnalysisSaveResult(doc *map[string]interface{}, result map[string][]*ju.ExtField, task *TaskInfo) {
	_id := qu.BsonIdToSId((*doc)["_id"])
	//结果排序
	values := map[string][]*ju.SortObject{}
	for key, val := range result {
		fieldValue := map[string][]interface{}{}
		for _, v := range val {
			if fieldValue[fmt.Sprint(v.Value)] == nil {
				fieldValue[fmt.Sprint(v.Value)] = []interface{}{0, v.Value}
			} else {
				fieldValue[fmt.Sprint(v.Value)][0] = qu.IntAll(fieldValue[fmt.Sprint(v.Value)][0]) + 1
			}
		}
		objects := []*ju.SortObject{}
		for k, v := range fieldValue {
			tmp := &ju.SortObject{
				Key:    k,
				Value:  qu.IntAll(v[0]),
				Object: v[1],
			}
			objects = append(objects, tmp)
		}
		values[key] = ju.ExtSort(objects)
	}
	//从排序结果中取值
	tmp := map[string]interface{}{} //抽取值
	resulttmp := tmp                //保存结果
	for key, val := range values {
		for _, v := range val { //取第一个
			if v.Key != "" {
				tmp[key] = v.Object
				break
			}
		}
	}
	resulttmp["result"] = result
	for k, v := range *doc {
		if resulttmp[k] == nil { //&& (k != "detail" || k != "contenthtml") {
			resulttmp[k] = v
		}
	}
	b, p, c, d := TransmitData(resulttmp, _id) //抽取省份城市
	//log.Println("抽取省份，城市，县结果=====", b, p, c, d)
	resulttmp["district"] = d
	if b {
		resulttmp["city"] = c
		resulttmp["area"] = p
	}
	if task.TestColl == "" {
		if len(tmp) > 0 { //保存抽取结果
			task.DB.Update(task.SaveColl, `{"_id":"`+_id+`"}`, map[string]interface{}{"$set": tmp}, true, false)
		}
		db.Mgo.Update("extract_result", `{"_id":"`+_id+`"}`, map[string]interface{}{"$set": resulttmp}, true, false)
	} else { //测试结果
		db.Mgo.Update(task.TestColl, `{"_id":"`+_id+`"}`, map[string]interface{}{"$set": resulttmp}, true, false)
	}
}