data_ai/ul/global.go

package ul

import (
	qu "jygit.jydev.jianyu360.cn/data_processing/common_utils"
	"strings"
)

var Unset_Check = map[string]interface{}{"winner": 1, "s_winner": 1, "bidamount": 1, "winnerorder": 1}

// 大模型与抽取数据合并计算
func ChooseCheckDataAI(tmp map[string]interface{}, update_info *map[string]interface{}) bool {
	if tmp["ai_zhipu"] == nil {
		return false
	}
	//记录抽取原值
	ext_ai_record := map[string]interface{}{}
	ai_zhipu := *qu.ObjToMap(tmp["ai_zhipu"])
	//选取分类
	s_toptype, s_subtype := ChooseTheBestClassField(ai_zhipu, tmp, update_info, &ext_ai_record)
	//选取字段
	ChooseTheBestCoreField(ai_zhipu, s_toptype, s_subtype, tmp, update_info, &ext_ai_record)

	//选取分包
	ChooseTheBestPackageField(ai_zhipu, s_toptype, s_subtype, tmp, update_info, &ext_ai_record)

	//最终金额修正与选取
	ChooseTheBestAmountField(tmp, update_info)

	//字段记录
	(*update_info)["ext_ai_record"] = ext_ai_record

	//跨分类是否删除结果类字段
	if s_subtype == "单一" || s_subtype == "中标" || s_subtype == "成交" || s_subtype == "合同" {

	} else {
		for k, _ := range Unset_Check {
			if tmp[k] != nil {
				return true
			}
		}
	}

	return false
}

// 选取分类
func ChooseTheBestClassField(ai_zhipu map[string]interface{}, tmp map[string]interface{}, update_info *map[string]interface{}, ext_ai_record *map[string]interface{}) (string, string) {
	//分类字段···
	s_toptype, s_subtype := qu.ObjToString(ai_zhipu["s_toptype"]), qu.ObjToString(ai_zhipu["s_subtype"])
	ns_toptype, ns_subtype := CheckClassByOtherFileds(s_toptype, s_subtype, tmp)
	if ns_toptype != s_toptype || ns_subtype != s_subtype {
		(*ext_ai_record)["s_toptype"] = ns_toptype
		(*ext_ai_record)["s_subtype"] = ns_subtype
	}
	//赋值···
	s_toptype, s_subtype = ns_toptype, ns_subtype
	if qu.ObjToString(tmp["toptype"]) == "拟建" || qu.ObjToString(tmp["toptype"]) == "产权" {
		s_toptype = qu.ObjToString(tmp["toptype"])
		s_subtype = qu.ObjToString(tmp["subtype"])
	} else {
		if s_toptype != "" && s_subtype != "" {
			(*update_info)["toptype"] = s_toptype
			(*update_info)["subtype"] = s_subtype
			(*ext_ai_record)["toptype"] = tmp["toptype"]
			(*ext_ai_record)["subtype"] = tmp["subtype"]
		} else {
			s_toptype = qu.ObjToString(tmp["toptype"])
			s_subtype = qu.ObjToString(tmp["subtype"])
		}
	}
	return s_toptype, s_subtype
}

// 选取字段
func ChooseTheBestCoreField(ai_zhipu map[string]interface{}, s_toptype string, s_subtype string, tmp map[string]interface{}, update_info *map[string]interface{}, ext_ai_record *map[string]interface{}) {
	//基础字段···
	if s_buyer := qu.ObjToString(ai_zhipu["s_buyer"]); s_buyer != "" {
		(*update_info)["buyer"] = s_buyer
		(*ext_ai_record)["buyer"] = tmp["buyer"]
		if agency := qu.ObjToString(tmp["agency"]); agency != "" && agency == s_buyer {
			delete((*update_info), "buyer")
			delete((*ext_ai_record), "buyer")
		}
	}
	if s_projectname := qu.ObjToString(ai_zhipu["s_projectname"]); s_projectname != "" {
		(*update_info)["projectname"] = s_projectname
		(*ext_ai_record)["projectname"] = tmp["projectname"]
	}
	if s_projectcode := qu.ObjToString(ai_zhipu["s_projectcode"]); s_projectcode != "" {
		(*update_info)["projectcode"] = s_projectcode
		(*ext_ai_record)["projectcode"] = tmp["projectcode"]
	}
	if s_budget := qu.Float64All(ai_zhipu["s_budget"]); s_budget > 0.0 && s_budget < 1000000000.0 {
		(*update_info)["budget"] = s_budget
		(*ext_ai_record)["budget"] = tmp["budget"]
	}
	//地域字段···
	o_area, o_district := qu.ObjToString(tmp["area"]), qu.ObjToString(tmp["district"])
	s_area, s_city := qu.ObjToString(ai_zhipu["s_area"]), qu.ObjToString(ai_zhipu["s_city"])
	if s_area != "" && s_area != "全国" {
		(*update_info)["area"] = s_area
		if s_city != "" {
			(*update_info)["city"] = s_city
			if o_district != "" {
				//判断抽取的区县是否合理···
				isT := false
				if ds := S_DistrictDict[o_district]; ds != nil {
					for _, v := range ds {
						if v.C_Name == s_city && v.P_Name == s_area {
							isT = true
							break
						}
					}
				}
				if !isT {
					(*update_info)["district"] = ""
				}
			}
		} else {
			if o_area != s_area {
				(*update_info)["city"] = ""
				(*update_info)["district"] = ""
			}
		}
		(*ext_ai_record)["area"] = tmp["area"]
		(*ext_ai_record)["city"] = tmp["city"]
		(*ext_ai_record)["district"] = tmp["district"]
	}
	//先用外围字段替换
	if s_subtype == "中标" || s_subtype == "成交" || s_subtype == "合同" || s_subtype == "单一" {
		if s_bidamount := qu.Float64All(ai_zhipu["s_bidamount"]); s_bidamount > 0.0 && s_bidamount < 1000000000.0 {
			(*update_info)["bidamount"] = s_bidamount
			(*ext_ai_record)["bidamount"] = tmp["bidamount"]
		}
		if s_winner := qu.ObjToString(ai_zhipu["s_winner"]); s_winner != "" {
			(*update_info)["s_winner"] = s_winner
			(*ext_ai_record)["s_winner"] = tmp["s_winner"]
			(*update_info)["winner"] = s_winner
			(*ext_ai_record)["winner"] = tmp["winner"]
			//对于winner来说...规则值有包含关系，采用规则值
			if winner := qu.ObjToString(tmp["winner"]); winner != "" {
				if strings.Contains(s_winner, winner) {
					delete((*update_info), "winner")
					delete((*ext_ai_record), "winner")
				}
			}
		}
		//旧版弃用
		//isRulePkg := false
		//if pkg := *qu.ObjToMap(tmp["package"]); len(pkg) > 1 && (s_subtype == "中标" || s_subtype == "成交" || s_subtype == "合同") {
		//	if !staffInfo(pkg) {
		//		isRulePkg = true
		//	}
		//}
		//if isRulePkg { //优先采用大模型分包-值替换
		//	if ispkg, ok := ai_zhipu["ispkg"].(bool); ispkg && ok {
		//		if s_pkg := qu.ObjToMap(ai_zhipu["s_pkg"]); s_pkg != nil {
		//			if p_winner := qu.ObjToString((*s_pkg)["s_winner"]); p_winner != "" {
		//				(*update_check)["s_winner"] = p_winner
		//				(*update_check)["winner"] = p_winner
		//				ext_ai_record["s_winner"] = tmp["s_winner"]
		//				ext_ai_record["winner"] = tmp["winner"]
		//			}
		//			if p_bidamount := qu.Float64All((*s_pkg)["s_bidamount"]); p_bidamount > 0.0 {
		//				(*update_check)["bidamount"] = p_bidamount
		//				ext_ai_record["bidamount"] = tmp["bidamount"]
		//			}
		//			if s_package := qu.ObjToMap((*s_pkg)["s_pkg"]); s_package != nil {
		//				(*update_check)["package"] = s_package
		//				ext_ai_record["package"] = tmp["package"]
		//			}
		//		}
		//	}
		//}
	} else {

	}
}

// 选取分包
func ChooseTheBestPackageField(ai_zhipu map[string]interface{}, s_toptype string, s_subtype string, tmp map[string]interface{}, update_info *map[string]interface{}, ext_ai_record *map[string]interface{}) {
	//新分包判定···com_package - 默认大模型分包可信
	if s_pkg := qu.ObjToMap(ai_zhipu["s_pkg"]); s_pkg != nil {
		com_package := IsMarkInterfaceMap((*s_pkg)["com_package"])
		//是否替换外围字段···质谱外围是否已提取
		if len(com_package) > 1 { //多包字段覆盖
			//校验核对分包结构
			new_com_package := staffAiPackageInfo(com_package, s_toptype, s_subtype)
			(*update_info)["com_package"] = new_com_package

			if p_budget := qu.Float64All((*s_pkg)["s_budget"]); p_budget > 0.0 {
				(*update_info)["budget"] = p_budget
				(*ext_ai_record)["budget"] = tmp["budget"]
			}
			if s_subtype == "单一" || s_subtype == "中标" || s_subtype == "成交" || s_subtype == "合同" {
				if p_winner := qu.ObjToString((*s_pkg)["s_winner"]); p_winner != "" {
					(*update_info)["s_winner"] = p_winner
					(*update_info)["winner"] = p_winner
					(*ext_ai_record)["s_winner"] = tmp["s_winner"]
					(*ext_ai_record)["winner"] = tmp["winner"]

					//对于winner来说...规则值有包含关系，采用规则值应用判重
					if winner := qu.ObjToString(tmp["winner"]); winner != "" {
						if strings.Contains(p_winner, winner) {
							delete((*update_info), "winner")
							delete((*ext_ai_record), "winner")
						}
					}
				}
				if p_bidamount := qu.Float64All((*s_pkg)["s_bidamount"]); p_bidamount > 0.0 {
					(*update_info)["bidamount"] = p_bidamount
					(*ext_ai_record)["bidamount"] = tmp["bidamount"]
				}
			}
		} else if len(com_package) == 1 { //单包字段覆盖
			if p_budget := qu.Float64All((*s_pkg)["s_budget"]); p_budget > 0.0 && (*update_info)["budget"] == nil {
				(*update_info)["budget"] = p_budget
				(*ext_ai_record)["budget"] = tmp["budget"]
			}
			if s_subtype == "单一" || s_subtype == "中标" || s_subtype == "成交" || s_subtype == "合同" {
				if p_winner := qu.ObjToString((*s_pkg)["s_winner"]); p_winner != "" && (*update_info)["s_winner"] == nil {
					(*update_info)["s_winner"] = p_winner
					(*update_info)["winner"] = p_winner
					(*ext_ai_record)["s_winner"] = tmp["s_winner"]
					(*ext_ai_record)["winner"] = tmp["winner"]

					//对于winner来说...规则值有包含关系，采用规则值应用判重
					if winner := qu.ObjToString(tmp["winner"]); winner != "" {
						if strings.Contains(p_winner, winner) {
							delete((*update_info), "winner")
							delete((*ext_ai_record), "winner")
						}
					}
				}
				if p_bidamount := qu.Float64All((*s_pkg)["s_bidamount"]); p_bidamount > 0.0 && (*update_info)["bidamount"] == nil {
					(*update_info)["bidamount"] = p_bidamount
					(*ext_ai_record)["bidamount"] = tmp["bidamount"]
				}
			}
		} else {

		}
	}
}

// 选取金额
func ChooseTheBestAmountField(tmp map[string]interface{}, update_info *map[string]interface{}) {
	if r_budget := qu.Float64All((*update_info)["budget"]); r_budget > 0.0 && r_budget < 1000000000.0 {
		if o_budget := qu.Float64All(tmp["budget"]); o_budget > 0.0 {
			if r_budget/o_budget == 10000.0 || o_budget/r_budget == 10000.0 {
				(*update_info)["budget"] = filterAmount(r_budget, o_budget)
			}
		}
	}
	if r_bidamount := qu.Float64All((*update_info)["bidamount"]); r_bidamount > 0.0 && r_bidamount < 1000000000.0 {
		if o_bidamount := qu.Float64All(tmp["bidamount"]); o_bidamount > 0.0 {
			if r_bidamount/o_bidamount == 10000.0 || o_bidamount/r_bidamount == 10000.0 {
				(*update_info)["bidamount"] = filterAmount(r_bidamount, o_bidamount)
			}
		}
	}
}

// 筛选金额
func filterAmount(f1 float64, f2 float64) float64 {
	//选取一个合适的金额 ...
	if f1 > f2 {
		if f1 > 100000000.0 {
			return f2
		} else {
			return f1
		}
	} else if f1 < f2 {
		if f2 > 100000000.0 {
			return f1
		} else {
			return f2
		}
	} else {
		return f1
	}
}

// 核算分包信息
func staffInfo(pkg map[string]interface{}) bool {
	//鉴定中标单位
	is_w := 0
	for _, v := range pkg {
		info := *qu.ObjToMap(v)
		if winner := qu.ObjToString(info["winner"]); winner != "" {
			is_w++
		}
	}
	//鉴定中标金额
	is_b := 0
	for _, v := range pkg {
		info := *qu.ObjToMap(v)
		if bidamount := qu.Float64All(info["bidamount"]); bidamount > 0.0 {
			is_b++
		}
	}
	if is_w != len(pkg) && is_w > 0 {
		return false
	}
	if is_b != len(pkg) && is_b > 0 {
		return false
	}
	if is_w == 0 || is_b == 0 {
		return false
	}
	return true
}

// 核对ai分包
func staffAiPackageInfo(com_package []map[string]interface{}, s_toptype string, s_subtype string) []map[string]interface{} {
	if s_subtype == "单一" || s_subtype == "中标" || s_subtype == "成交" || s_subtype == "合同" {
		return com_package
	}
	new_com_package := []map[string]interface{}{}
	for _, v := range com_package {
		delete(v, "winner")
		delete(v, "bidamount")
		new_com_package = append(new_com_package, v)
	}
	return new_com_package
}

// 核对分类
func CheckClassByOtherFileds(toptype_ai, subtype_ai string, data map[string]interface{}) (string, string) {
	toptype_rule := qu.ObjToString(data["toptype"])
	subtype_rule := qu.ObjToString(data["subtype"])
	//1、结果类 中标和成交错误校正
	s_winner := qu.ObjToString(data["s_winner"])
	winnerorder := IsMarkInterfaceMap(data["winnerorder"])
	if toptype_ai == "结果" && toptype_rule == "结果" {
		if subtype_ai == "成交" && subtype_rule == "成交" && len(winnerorder) > 0 { //规则、大模型都错
			return "结果", "中标"
		}
		if ((subtype_ai == "中标" || subtype_ai == "其它") && subtype_rule == "成交") || ((subtype_ai == "成交" || subtype_ai == "其它") && subtype_rule == "中标") {
			if len(winnerorder) > 0 { //有中标候选人->中标
				return toptype_ai, "中标"
			}
			if s_winner != "" || data["bidamount"] != nil {
				return toptype_ai, "成交"
			}
		}
	}
	//2、招标、结果错误校正
	if toptype_ai != "结果" && toptype_rule == "结果" {
		//return toptype_rule,subtype_rule//默认规则为准
		if len(winnerorder) > 0 || s_winner != "" || data["bidamount"] != nil {
			return toptype_rule, subtype_rule
		} else {
			return toptype_ai, subtype_ai
		}
	} else if toptype_ai == "结果" && toptype_rule != "结果" && (subtype_ai == "中标" || subtype_ai == "成交") { //结果-变更
		//return toptype_rule,subtype_rule//默认规则为准
		if len(winnerorder) > 0 { //有中标候选人->中标
			return toptype_ai, "中标" //这里subtype返回"中标"，避免ai识别错误
		} else if s_winner != "" || data["bidamount"] != nil {
			return toptype_ai, "成交" //这里subtype返回"成交"，避免ai识别错误
		} else {
			return toptype_ai, subtype_ai
		}
	}
	return toptype_ai, subtype_ai
}