人工审核

udp_winner/config.json

@@ -20,10 +20,11 @@
   "mgo_qyk_c": "enterprise_qyxy",
   "mgo_qyk_buyer": "buyer_qyxy",
   "mgo_qyk_agency": "agency_qyxy",
+  "mgo_qyk_reg": "rc_rule",
   "redis": "127.0.0.1:6379",
   "redis_winner_db": "1",
   "redis_buyer_db": "2",
   "redis_agency_db": "3",
   "chan_pool_num": "10",
-  "mongo_reg_c": "rc_rule"
+  "his_redis": "127.0.0.1:6380"
 }

udp_winner/main.go

@@ -34,6 +34,10 @@ var (
 	EsConn                                *es.Client
 	Updport                               int
 	CPool                                 chan bool
+	//his_redis db
+	redis_winner_db, redis_buyer_db, redis_agency_db int
+	//异常表正则匹配处理
+	WinnerRegOk, WinnerRegErr, AgencyRegOk, AgencyRegErr, BuerRegOk, BuyerRegErr []regexp.Regexp
 )
 
 /**
@@ -54,7 +58,7 @@ func init() {
 		"capital", "establish_date", "legal_person", "company_type",
 		"district", "city", "province", "area_code", "credit_no",
 		"company_name", "history_name", "wechat_accounts",
-		"alias", "website", "report_websites","industry"}
+		"alias", "website", "report_websites", "industry"}
 
 	BuyerFields = []string{"_id", "contact", "type", "ranks", "buyerclass",
 		"address", "district", "city", "province", "area_code", "credit_no", "buyer_name",
@@ -79,7 +83,7 @@ func init() {
 	FClient.DbName = Config["mgodb_extract_kf"]
 	//mongodbSim.DbName = "qfw"
 	FClient.InitPool()
-	FClientmgoConn := FClient.GetMgoConn(86400)
+	FClientmgoConn := FClient.GetMgoConn()
 	defer FClient.DestoryMongoConn(FClientmgoConn)
 	//加载省市县代码
 	cursor2 := FClientmgoConn.DB(Config["mgodb_extract_kf"]).C("address").Find(bson.M{}).Select(bson.M{"province": 1, "code": 1, "city": 1, "district": 1}).Iter()
@@ -121,7 +125,7 @@ func init() {
 	}
 	c.Close()
 	HisRedisPool = hisRedis.NewClient(&hisRedis.Options{
-		Addr:         "127.0.0.1:6380",
+		Addr:         Config["his_redis"],
 		DB:           1,
 		DialTimeout:  10 * time.Second,
 		ReadTimeout:  30 * time.Second,
@@ -130,6 +134,49 @@ func init() {
 		MinIdleConns: 20,
 		PoolTimeout:  30 * time.Second,
 	})
+	redis_winner_db, _ = strconv.Atoi(Config["redis_winner_db"])
+	redis_buyer_db, _ = strconv.Atoi(Config["redis_buyer_db"])
+	redis_agency_db, _ = strconv.Atoi(Config["redis_agency_db"])
+	iniReg()
+
+}
+
+func iniReg() {
+	FClientmgoConnReg := FClient.GetMgoConn()
+	defer FClient.DestoryMongoConn(FClientmgoConnReg)
+	findReg, b := FClient.Find(Config["mgo_qyk_reg"], bson.M{"delete": false, "isuse": true}, bson.M{"_id": 1}, nil, false, -1, 0)
+	if !b {
+		log.Fatalln("查询正则失败")
+	}
+	for _, v := range (*findReg) {
+		s_field, ok := v["s_field"].(string) //字段
+		s_rule, ok2 := v["s_rule"].(string)  //正则
+		s_type, ok3 := v["s_type"].(string)  //ok or err
+		if !ok || !ok2 || !ok3 || s_field == "" || s_rule == "" || s_type == "" {
+			continue
+		}
+		regtmp := regexp.MustCompile(s_rule)
+		if s_field == "winner" {
+			if s_type=="ok"{
+				WinnerRegOk = append(WinnerRegOk, *regtmp)
+			}else if s_type=="err"{
+				WinnerRegErr = append(WinnerRegErr, *regtmp)
+			}
+		} else if s_field == "buyer" {
+			if s_type=="ok"{
+				BuerRegOk = append(BuerRegOk, *regtmp)
+			}else if s_type=="err"{
+				BuyerRegErr = append(BuyerRegErr, *regtmp)
+			}
+		} else if s_field == "agency" {
+			if s_type=="ok"{
+				AgencyRegOk = append(AgencyRegOk, *regtmp)
+			}else if s_type=="err"{
+				AgencyRegErr = append(AgencyRegErr, *regtmp)
+			}
+		}
+	}
+	log.Println(len(WinnerRegOk), len(WinnerRegErr), len(BuerRegOk), len(BuyerRegErr), len(AgencyRegOk), len(AgencyRegErr))
 }
 
 func main() {

udp_winner/timedTaskAgency.go

@@ -10,7 +10,6 @@ import (
 	"net"
 	"qfw/util"
 	"sort"
-	"strconv"
 	"strings"
 	"time"
 	"unicode/utf8"
@@ -57,14 +56,13 @@ func TaskAgency(mapinfo *map[string]interface{}) {
 		conn := HisRedisPool.Conn()
 		defer conn.Close()
 		//选择redis db
-		redis_agency_db, _ := strconv.Atoi(Config["redis_agency_db"])
 		conn.Select(redis_agency_db)
 		//遍历bidding表保存到redis
 		//key：企业名  value:json结构体{"agency": 1, "agencytel": 1, "agencyperson": 1,"topscopeclass": 1, "agencyaddr": 1,"_id":1}
 		tmp := make(map[string]interface{})
 		for cursor.Next(&tmp) {
 			agency, ok := tmp["agency"].(string)
-			if !ok ||utf8.RuneCountInString(agency)<4{
+			if !ok || utf8.RuneCountInString(agency) < 4 {
 				continue
 			}
 			//判断redis key是否存在
@@ -103,14 +101,14 @@ func TaskAgency(mapinfo *map[string]interface{}) {
 				json.Unmarshal(redisvalueBytes, &rValuesMaps)
 				//redis查询是否存在
 				rdb := RedisPool.Get()
-				rdb.Do("SELECT", Config["redis_agency_db"])
+				rdb.Do("SELECT", redis_agency_db)
 				if reply, err := redis.String(rdb.Do("GET", redisCName)); err != nil {
 					//redis不存在,存到临时表,定时任务处理
 					FClient.DbName = Config["mgodb_extract_kf"]
 					for _, vmap := range rValuesMaps {
 						vmap["_id"] = bson.ObjectIdHex(vmap["_id"].(string))
 						if err = FClient.SaveForOld("agency_new", vmap); err != nil {
-							log.Println("存量 FClient.Save err", err,vmap)
+							log.Println("存量 FClient.Save err", err, vmap)
 						}
 					}
 					//log.Println("get redis id err:定时任务处理", err, tmp)
@@ -214,17 +212,17 @@ func TaskAgency(mapinfo *map[string]interface{}) {
 			overid = tmp["_id"].(bson.ObjectId).Hex()
 			//log.Println(tmp["_id"])
 			agency, ok := tmp["agency"].(string)
-			if !ok ||utf8.RuneCountInString(agency)<4{
+			if !ok || utf8.RuneCountInString(agency) < 4 {
 				continue
 			}
 			//redis查询是否存在
 			rdb := RedisPool.Get()
-			rdb.Do("SELECT", Config["redis_agency_db"])
+			rdb.Do("SELECT", redis_agency_db)
 			if reply, err := redis.String(rdb.Do("GET", agency)); err != nil {
 				//redis不存在存到临时表,定时任务处理
 				FClient.DbName = Config["mgodb_extract_kf"]
-				if err := FClient.SaveForOld("agency_new", tmp); err!=nil {
-					log.Println("FClient.Save err", err,tmp)
+				if err := FClient.SaveForOld("agency_new", tmp); err != nil {
+					log.Println("FClient.Save err", err, tmp)
 				}
 				//log.Println("get redis id err:定时任务处理", err, tmp)
 				if err := rdb.Close(); err != nil {
@@ -361,10 +359,14 @@ func TimedTaskAgency() {
 				tmp := make(map[string]interface{})
 				for cursor.Next(&tmp) {
 					tmpId := tmp["_id"].(bson.ObjectId).Hex()
+					erragency, ok := tmp["agency"].(string)
+					if !ok || erragency == "" {
+						continue
+					}
 					//再重新查找redis,存在发udp处理，不存在走新增合并
 					rdb := RedisPool.Get()
-					rdb.Do("SELECT", Config["redis_agency_db"])
-					if _, err := redis.String(rdb.Do("GET", tmp["agency"])); err == nil {
+					rdb.Do("SELECT", redis_agency_db)
+					if _, err := redis.String(rdb.Do("GET", erragency)); err == nil {
 						//redis存在发送udp进行处理
 						by, _ := json.Marshal(map[string]interface{}{
 							"gtid":      tmpId,
@@ -396,11 +398,24 @@ func TimedTaskAgency() {
 					//查询redis不存在新增
 					FClient.DbName = Config["mgodb_enterprise"]
 
-					resulttmp, b := FClient.FindOne(Config["mgodb_enterprise_c"], bson.M{"company_name": tmp["agency"]})
+					resulttmp, b := FClient.FindOne(Config["mgodb_enterprise_c"], bson.M{"company_name": erragency})
 					if !b || (*resulttmp)["_id"] == nil {
 						//log.Println(r)
+						//人工审核正则
+						var isok bool
+						for _, v := range AgencyRegOk {
+							isok = v.MatchString(erragency)
+							if isok {
+								tmp["agency_ok"] = 1
+								break
+							}
+						}
+						if tmp["agency_ok"] == nil{
+							tmp["agency_err"] =1
+						}
 						//匹配不到原始库,存入异常表删除临时表
 						FClient.DbName = Config["mgodb_extract_kf"]
+						//winner_err winner_ok buyer_err buyer_err agency_err agency_ok
 						if err := FClient.SaveForOld("agency_err", tmp); err != nil {
 							log.Println("存入异常表错误", err, tmp)
 						}
@@ -472,16 +487,16 @@ func TimedTaskAgency() {
 						//添加临时表匹配到的联系人
 						vvv := make(map[string]interface{})
 						vvv["infoid"] = tmp["_id"].(bson.ObjectId).Hex()
-						if tmp["agencyperson"] != nil{
+						if tmp["agencyperson"] != nil {
 							vvv["contact_person"] = tmp["agencyperson"]
-						}else {
+						} else {
 							vvv["contact_person"] = ""
 						}
 						vvv["contact_type"] = "项目联系人"
 						//	"agency": 1, "agencytel": 1, "agencyperson": 1, "topscopeclass": 1
-						if tmp["agencytel"] != nil{
+						if tmp["agencytel"] != nil {
 							vvv["phone"] = tmp["agencytel"]
-						}else {
+						} else {
 							vvv["phone"] = ""
 						}
 						tmpclass := make([]string, 0)
@@ -528,23 +543,22 @@ func TimedTaskAgency() {
 							} else if sk == "wechat_accounts" {
 								savetmp[sk] = []interface{}{}
 								continue
-							}else if sk=="agency_name" {
+							} else if sk == "agency_name" {
 								if (*resulttmp)["company_name"] == nil {
 									savetmp[sk] = ""
-								}else {
+								} else {
 									savetmp[sk] = (*resulttmp)["company_name"]
 								}
 								continue
-							}else if sk=="address"{
+							} else if sk == "address" {
 								if (*resulttmp)["company_address"] == nil {
 									savetmp[sk] = ""
-								}else {
+								} else {
 									savetmp[sk] = (*resulttmp)["company_address"]
 								}
 								continue
 							}
 
-
 							if (*resulttmp)[sk] == nil && sk != "history_name" && sk != "wechat_accounts" &&
 								sk != "agency_name" && sk != "address" &&
 								sk != "contact" && sk != "report_websites" {
@@ -558,13 +572,11 @@ func TimedTaskAgency() {
 						//保存mongo
 						FClient.DbName = Config["mgodb_extract_kf"]
 
-
-
 						saveid := FClient.Save(Config["mgo_qyk_agency"], savetmp)
 						if saveid != "" {
 							//保存redis
 							rc := RedisPool.Get()
-							rc.Do("SELECT", Config["redis_agency_db"])
+							rc.Do("SELECT", redis_agency_db)
 							//var _id string
 							//if v, ok := saveid.(primitive.ObjectID); ok {
 							//	_id = v.Hex()
@@ -605,4 +617,3 @@ func TimedTaskAgency() {
 		t2.Reset(time.Minute)
 	}
 }
-

udp_winner/timedTaskBuyer.go

@@ -10,7 +10,6 @@ import (
 	"net"
 	"qfw/util"
 	"sort"
-	"strconv"
 	"strings"
 	"time"
 	"unicode/utf8"
@@ -45,7 +44,7 @@ func TaskBuyer(mapinfo *map[string]interface{}) {
 			"$lte": LtId,
 		},
 	}).Select(bson.M{"buyer": 1, "buyertel": 1, "buyerperson": 1, "topscopeclass": 1,
-		"buyeraddr": 1,"buyerclass":1}).Iter()
+		"buyeraddr": 1, "buyerclass": 1}).Iter()
 	if cursor.Err() != nil {
 		SourceClient.DestoryMongoConn(SourceClientcc)
 		log.Println(cursor.Err())
@@ -57,14 +56,13 @@ func TaskBuyer(mapinfo *map[string]interface{}) {
 		conn := HisRedisPool.Conn()
 		defer conn.Close()
 		//选择redis db
-		redis_buyer_db, _ := strconv.Atoi(Config["redis_buyer_db"])
 		conn.Select(redis_buyer_db)
 		//遍历bidding表保存到redis
 		//key：企业名  value:json结构体{"buyer": 1, "buyertel": 1, "buyerperson": 1,"topscopeclass": 1, "buyeraddr": 1,"_id":1}
 		tmp := make(map[string]interface{})
 		for cursor.Next(&tmp) {
 			buyer, ok := tmp["buyer"].(string)
-			if !ok || utf8.RuneCountInString(buyer)<4{
+			if !ok || utf8.RuneCountInString(buyer) < 4 {
 				continue
 			}
 			//判断redis key是否存在
@@ -103,14 +101,14 @@ func TaskBuyer(mapinfo *map[string]interface{}) {
 				json.Unmarshal(redisvalueBytes, &rValuesMaps)
 				//redis查询是否存在
 				rdb := RedisPool.Get()
-				rdb.Do("SELECT", Config["redis_buyer_db"])
+				rdb.Do("SELECT", redis_buyer_db)
 				if reply, err := redis.String(rdb.Do("GET", redisCName)); err != nil {
 					//redis不存在,存到临时表,定时任务处理
 					FClient.DbName = Config["mgodb_extract_kf"]
 					for _, vmap := range rValuesMaps {
 						vmap["_id"] = bson.ObjectIdHex(vmap["_id"].(string))
 						if err = FClient.SaveForOld("buyer_new", vmap); err != nil {
-							log.Println("存量 FClient.Save err", err,vmap)
+							log.Println("存量 FClient.Save err", err, vmap)
 						}
 					}
 					//log.Println("get redis id err:定时任务处理", err, tmp)
@@ -148,20 +146,19 @@ func TaskBuyer(mapinfo *map[string]interface{}) {
 					sort.Strings(tmpTopscopeclass)
 					esId := (*oldTmp)["_id"].(bson.ObjectId).Hex()
 
-
 					//更新buyerclass合并
 					if tmp["buyerclass"] == nil || tmp["buyerclass"] == "" {
 						//无值，不更新
-					}else {
-						var buyerclass_new,buyerclass_old string
+					} else {
+						var buyerclass_new, buyerclass_old string
 						buyerclass_new = tmp["buyerclass"].(string)
 						buyerclass_old = (*oldTmp)["buyerclass"].(string)
-						if buyerclass_old=="" {
+						if buyerclass_old == "" {
 							(*oldTmp)["buyerclass"] = buyerclass_new
-						}else {
-							if buyerclass_new!=buyerclass_old {
+						} else {
+							if buyerclass_new != buyerclass_old {
 								if !strings.Contains(buyerclass_old, buyerclass_new) {
-									(*oldTmp)["buyerclass"] = buyerclass_old + ","+buyerclass_new //采购单位类型
+									(*oldTmp)["buyerclass"] = buyerclass_old + "," + buyerclass_new //采购单位类型
 								}
 							}
 						}
@@ -233,17 +230,17 @@ func TaskBuyer(mapinfo *map[string]interface{}) {
 			overid = tmp["_id"].(bson.ObjectId).Hex()
 			//log.Println(tmp["_id"])
 			buyer, ok := tmp["buyer"].(string)
-			if !ok || utf8.RuneCountInString(buyer)<4{
+			if !ok || utf8.RuneCountInString(buyer) < 4 {
 				continue
 			}
 			//redis查询是否存在
 			rdb := RedisPool.Get()
-			rdb.Do("SELECT", Config["redis_buyer_db"])
+			rdb.Do("SELECT", redis_buyer_db)
 			if reply, err := redis.String(rdb.Do("GET", buyer)); err != nil {
 				//redis不存在存到临时表,定时任务处理
 				FClient.DbName = Config["mgodb_extract_kf"]
-				if err := FClient.SaveForOld("buyer_new", tmp); err!=nil {
-					log.Println("FClient.Save err", err,tmp)
+				if err := FClient.SaveForOld("buyer_new", tmp); err != nil {
+					log.Println("FClient.Save err", err, tmp)
 				}
 				//log.Println("get redis id err:定时任务处理", err, tmp)
 				if err := rdb.Close(); err != nil {
@@ -281,20 +278,19 @@ func TaskBuyer(mapinfo *map[string]interface{}) {
 				sort.Strings(tmpTopscopeclass)
 				esId := (*oldTmp)["_id"].(bson.ObjectId).Hex()
 
-
 				//更新buyerclass合并
 				if tmp["buyerclass"] == nil || tmp["buyerclass"] == "" {
 					//无值，不更新
-				}else {
-					var buyerclass_new,buyerclass_old string
+				} else {
+					var buyerclass_new, buyerclass_old string
 					buyerclass_new = tmp["buyerclass"].(string)
 					buyerclass_old = (*oldTmp)["buyerclass"].(string)
-					if buyerclass_old=="" {
+					if buyerclass_old == "" {
 						(*oldTmp)["buyerclass"] = buyerclass_new
-					}else {
-						if buyerclass_new!=buyerclass_old {
+					} else {
+						if buyerclass_new != buyerclass_old {
 							if !strings.Contains(buyerclass_old, buyerclass_new) {
-								(*oldTmp)["buyerclass"] = buyerclass_old + ","+buyerclass_new //采购单位类型
+								(*oldTmp)["buyerclass"] = buyerclass_old + "," + buyerclass_new //采购单位类型
 							}
 						}
 					}
@@ -400,10 +396,14 @@ func TimedTaskBuyer() {
 				tmp := make(map[string]interface{})
 				for cursor.Next(&tmp) {
 					tmpId := tmp["_id"].(bson.ObjectId).Hex()
+					errbuyer, ok := tmp["buyer"].(string)
+					if !ok || errbuyer == "" {
+						continue
+					}
 					//再重新查找redis,存在发udp处理，不存在走新增合并
 					rdb := RedisPool.Get()
-					rdb.Do("SELECT", Config["redis_buyer_db"])
-					if _, err := redis.String(rdb.Do("GET", tmp["buyer"])); err == nil {
+					rdb.Do("SELECT", redis_buyer_db)
+					if _, err := redis.String(rdb.Do("GET", errbuyer)); err == nil {
 						//redis存在发送udp进行处理
 						by, _ := json.Marshal(map[string]interface{}{
 							"gtid":      tmpId,
@@ -435,9 +435,21 @@ func TimedTaskBuyer() {
 					//查询redis不存在新增
 					FClient.DbName = Config["mgodb_enterprise"]
 
-					resulttmp, b := FClient.FindOne(Config["mgodb_enterprise_c"], bson.M{"company_name": tmp["buyer"]})
+					resulttmp, b := FClient.FindOne(Config["mgodb_enterprise_c"], bson.M{"company_name": errbuyer})
 					if !b || (*resulttmp)["_id"] == nil {
 						//log.Println(r)
+						//人工审核
+						var isok bool
+						for _, v := range BuerRegOk {
+							isok = v.MatchString(errbuyer)
+							if isok {
+								tmp["buyer_ok"] = 1
+								break
+							}
+						}
+						if tmp["buyer_ok"] == nil {
+							tmp["buyer_err"] = 1
+						}
 						//匹配不到原始库,存入异常表删除临时表
 						FClient.DbName = Config["mgodb_extract_kf"]
 						if err := FClient.SaveForOld("buyer_err", tmp); err != nil {
@@ -600,7 +612,7 @@ func TimedTaskBuyer() {
 						if saveid != "" {
 							//保存redis
 							rc := RedisPool.Get()
-							rc.Do("SELECT", Config["redis_buyer_db"])
+							rc.Do("SELECT", redis_buyer_db)
 							//var _id string
 							//if v, ok := saveid.(primitive.ObjectID); ok {
 							//	_id = v.Hex()
@@ -641,4 +653,4 @@ func TimedTaskBuyer() {
 		FClient.DestoryMongoConn(Fcconn)
 		t2.Reset(time.Minute)
 	}
-}
+}

udp_winner/timedTaskWinner.go

@@ -10,7 +10,6 @@ import (
 	"net"
 	"qfw/util"
 	"sort"
-	"strconv"
 	"strings"
 	"time"
 	"unicode/utf8"
@@ -57,14 +56,13 @@ func TaskWinner(mapinfo *map[string]interface{}) {
 		conn := HisRedisPool.Conn()
 		defer conn.Close()
 		//选择redis db
-		redis_winner_db, _ := strconv.Atoi(Config["redis_winner_db"])
 		conn.Select(redis_winner_db)
 		//遍历bidding表保存到redis
 		//key：企业名  value:json结构体{"winner": 1, "winnertel": 1, "winnerperson": 1,"topscopeclass": 1, "winneraddr": 1,"_id":1}
 		tmp := make(map[string]interface{})
 		for cursor.Next(&tmp) {
 			winner, ok := tmp["winner"].(string)
-			if !ok ||utf8.RuneCountInString(winner)<4 {
+			if !ok || utf8.RuneCountInString(winner) < 4 {
 				continue
 			}
 			//判断redis key是否存在
@@ -101,7 +99,7 @@ func TaskWinner(mapinfo *map[string]interface{}) {
 				json.Unmarshal(redisvalueBytes, &rValuesMaps)
 				//redis查询是否存在
 				rdb := RedisPool.Get()
-				rdb.Do("SELECT", Config["redis_winner_db"])
+				rdb.Do("SELECT", redis_winner_db)
 				if reply, err := redis.String(rdb.Do("GET", redisCName)); err != nil {
 					//redis不存在,存到临时表,定时任务处理
 					FClient.DbName = Config["mgodb_extract_kf"]
@@ -229,7 +227,7 @@ func TaskWinner(mapinfo *map[string]interface{}) {
 			}
 			//redis查询是否存在
 			rdb := RedisPool.Get()
-			rdb.Do("SELECT", Config["redis_winner_db"])
+			rdb.Do("SELECT", redis_winner_db)
 			if reply, err := redis.String(rdb.Do("GET", winner)); err != nil {
 				//redis不存在存到临时表,定时任务处理
 				FClient.DbName = Config["mgodb_extract_kf"]
@@ -380,10 +378,14 @@ func TimedTaskWinner() {
 				tmp := make(map[string]interface{})
 				for cursor.Next(&tmp) {
 					tmpId := tmp["_id"].(bson.ObjectId).Hex()
+					errwinner, ok := tmp["winner"].(string)
+					if !ok || errwinner == "" {
+						continue
+					}
 					//再重新查找redis,存在发udp处理，不存在走新增合并
 					rdb := RedisPool.Get()
-					rdb.Do("SELECT", Config["redis_winner_db"])
-					if _, err := redis.String(rdb.Do("GET", tmp["winner"])); err == nil {
+					rdb.Do("SELECT", redis_winner_db)
+					if _, err := redis.String(rdb.Do("GET", errwinner)); err == nil {
 						//redis存在发送udp进行处理
 						by, _ := json.Marshal(map[string]interface{}{
 							"gtid":      tmpId,
@@ -415,9 +417,22 @@ func TimedTaskWinner() {
 					//查询redis不存在新增
 					FClient.DbName = Config["mgodb_enterprise"]
 
-					resulttmp, b := FClient.FindOne(Config["mgodb_enterprise_c"], bson.M{"company_name": tmp["winner"]})
+					resulttmp, b := FClient.FindOne(Config["mgodb_enterprise_c"], bson.M{"company_name": errwinner})
 					if !b || (*resulttmp)["_id"] == nil {
 						//log.Println(r)
+						//人工审核正则
+						var isok bool
+						for _, v := range WinnerRegOk {
+							isok = v.MatchString(errwinner)
+							if isok {
+								tmp["winner_ok"] = 1
+								break
+							}
+						}
+						if tmp["winner_ok"] == nil {
+							tmp["winner_err"] = 1
+						}
+
 						//匹配不到原始库,存入异常表删除临时表
 						FClient.DbName = Config["mgodb_extract_kf"]
 						if err := FClient.SaveForOld("winner_err", tmp); err != nil {
@@ -601,7 +616,7 @@ func TimedTaskWinner() {
 						if saveid != "" {
 							//保存redis
 							rc := RedisPool.Get()
-							rc.Do("SELECT", Config["redis_winner_db"])
+							rc.Do("SELECT", redis_winner_db)
 							//var _id string
 							//if v, ok := saveid.(primitive.ObjectID); ok {
 							//	_id = v.Hex()