yusuan/yusuan.go

package main

import (
	"log"
	"math"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"time"

	"app.yhyue.com/moapp/jybase/mongodb"
	"github.com/gogf/gf/v2/util/gconv"
)

var regString = `(\d+[.,]{0,}\d+)`
var reg, _ = regexp.Compile(regString)

// 从解析文档中提取全部项目信息
func getProjectItemFromFilejx() {

	list, _ := db.Find(cf.YusuanInfo, `{"handle":{"$exists":1}}`, nil, nil, false, -1, -1)
	//list, _ := db.Find(cf.YusuanInfo, `{"file_path" : "2024年/内蒙古/内蒙古/政府/2024_准格尔旗人民法院_9.xlsx"}`, nil, nil, false, -1, -1)

	pronum := 0
	for k, data := range *list {
		tmp, _ := data["performance_result"].([]interface{})
		if len(tmp) > 0 {
			for _, v := range tmp {
				t, _ := v.(map[string]interface{})
				tmp3, _ := t["sheetdata"].([]interface{})
				for _, v := range tmp3 {
					item, _ := v.(map[string]interface{})
					budget, ok := item["budget"]
					if ok {
						ty := reflect.TypeOf(budget).Kind()
						switch ty {
						case reflect.Int:
							item["budget_f"] = float64(budget.(int))
						case reflect.Int32:
							item["budget_f"] = float64(budget.(int32))
						case reflect.String:
							budget_f := budget.(string)
							if strings.Contains(budget_f, ",") {
								budget_f = strings.ReplaceAll(budget_f, ",", "")
							}
							rs, _ := strconv.ParseFloat(budget_f, 64)
							item["budget_f"] = rs
						default:
							item["budget_f"] = budget
						}
						unit, _ := item["unit"].(string)
						if strings.Contains(unit, "万") {
							item["budget_f"] = math.Round(item["budget_f"].(float64) * 10000)
						}
						budget_f := item["budget_f"].(float64)
						if unit == "" && budget_f < 1000 {
							item["budget_f"] = math.Round(budget_f * 10000)
						}
					} else {
						total_amount, ok := item["total_amount"]
						if ok {
							ty := reflect.TypeOf(total_amount).Kind()
							switch ty {
							case reflect.Int:
								item["budget_f"] = float64(total_amount.(int))
							case reflect.Int32:
								item["budget_f"] = float64(total_amount.(int32))
							case reflect.String:
								budget_f := total_amount.(string)
								if strings.Contains(budget_f, ",") {
									budget_f = strings.ReplaceAll(budget_f, ",", "")
								}
								rs, _ := strconv.ParseFloat(budget_f, 64)
								item["budget_f"] = rs
							default:
								item["budget_f"] = total_amount
							}
							unit, _ := item["unit"].(string)
							if strings.Contains(unit, "万") {
								item["budget_f"] = math.Round(item["budget_f"].(float64) * 10000)
							}
							budget_f := item["budget_f"].(float64)
							if unit == "" && budget_f < 1000 {
								item["budget_f"] = math.Round(budget_f * 10000)
							}
						}
					}
					for _, f := range cf.Projectitem_field {
						item[f] = data[f]
					}
					year := gconv.String(item["year"])
					projectname := gconv.String(item["projectname"])
					procure_content := gconv.String(item["procure_content"])
					kpi := gconv.String(item["kpi"])
					institution := gconv.String(item["institution"])
					//生成hashcode
					item["hash_code"] = Hash(year, projectname, procure_content, kpi, institution)
					item["fileitem_id"] = mongodb.BsonIdToSId(data["_id"])

					pronum++
					db.Save(cf.ProjectItem, item)
				}
			}
		}
		if k%1000 == 0 {
			log.Printf("加载数据量为：%d,生成项目数据量为：%d", k, pronum)
		}
	}
}

// 匹配客户项目信息
type Data struct {
	ismatch            bool
	isnotmatch         bool
	matchkey           map[string]bool
	matchkey_field     map[string]bool
	matchkey_add       map[string]bool
	matchkey_add_field map[string]bool
	notmatchkey        map[string]bool
	notmatchkey_field  map[string]bool

	rule_index string
}

func LoadingHash() map[string]bool {
	HashMap := map[string]bool{}
	sess := db.GetMgoConn()
	defer db.DestoryMongoConn(sess)

	it := sess.DB(cf.Collections).C(ucf.Totbale).Find(nil).Select(map[string]interface{}{
		"year":            1,
		"projectname":     1,
		"procure_content": 1,
		"kpi":             1,
		"institution":     1,
		"_id":             1,
		"hash_code":       1,
	}).Iter()
	i := 0
	for m := make(map[string]interface{}); it.Next(&m); {
		i++
		if i%1000 == 0 {
			log.Println("count:", i)
		}

		hash_code := gconv.String(m["hash_code"])
		HashMap[hash_code] = true

		m = make(map[string]interface{})
	}

	return HashMap
}

func getCustomerMatchProject() {
	log.Println("开始加载历史匹配数据")
	HashMap := LoadingHash()
	log.Println("历史匹配数据加载完毕，总数据量：", len(HashMap))
	log.Println("开始加载数据")
	list, _ := db.Find(cf.ProjectItem, nil, nil, nil, false, -1, -1)
	log.Println("加载完毕，总数据量：", len(*list))
	pipienum := 0
	for k, tmp := range *list {
		d := &Data{
			matchkey:           map[string]bool{},
			matchkey_field:     map[string]bool{},
			matchkey_add:       map[string]bool{},
			matchkey_add_field: map[string]bool{},
			notmatchkey:        map[string]bool{},
			notmatchkey_field:  map[string]bool{},
		}
		for _, rule := range ucf.Rules {
			//关键词
			mkey := strings.Split(rule.Match, ",")
			for _, field := range rule.MatchField.Field {
				content, _ := tmp[field].(string)
				//关键词匹配
				for _, key := range mkey {
					keys := strings.Split(key, "&&")
					ismatch := true
					for _, v := range keys {
						if !strings.Contains(content, v) {
							ismatch = false
							break
						}
					}
					if ismatch {
						d.ismatch = true
						d.matchkey[key] = true
						d.matchkey_field[field] = true
					}

				}
			}
			//处理附件词、排除词
			if d.ismatch {
				d.rule_index = rule.Index
				//附加词
				addkey := strings.Split(rule.MatchAdd, ",")
				if len(addkey) > 0 {
					//附加词匹配
					for _, key := range addkey {
						for _, field := range rule.MatchAddField.Field {
							content, _ := tmp[field].(string)
							if strings.Contains(content, key) {
								d.matchkey_add[key] = true
								d.matchkey_add_field[field] = true
							}
						}
					}
				}
				//排除词
				notkey := strings.Split(rule.NotMatch, ",")
				if len(notkey) > 0 {
					//附加词匹配
					for _, key := range notkey {
						for _, field := range rule.NotMatchField.Field {
							content, _ := tmp[field].(string)
							if strings.Contains(content, key) {
								d.notmatchkey[key] = true
								d.notmatchkey_field[field] = true
							}
						}
					}
				}
			}
		}
		if d.ismatch {
			//提取
			pipienum++
			tmp["matchkey"] = getKeyMap(d.matchkey)
			tmp["matchkey_filed"] = getKeyMap(d.matchkey_field)
			tmp["matchkey_add"] = getKeyMap(d.matchkey_add)
			tmp["matchkey_add_filed"] = getKeyMap(d.matchkey_add_field)
			tmp["matchkey_not"] = getKeyMap(d.notmatchkey)
			tmp["matchkey_not_filed"] = getKeyMap(d.notmatchkey_field)

			//TODO 	判断判重
			hash_code := gconv.String(tmp["hash_code"])
			if HashMap[hash_code] {
				tmp["repeat"] = -1
			} else {
				tmp["repeat"] = 1
			}

			tmp["rule_index"] = d.rule_index
			tmp["comeintime"] = time.Now().Unix()

			if tmp["contact_person"] == nil {
				tmp["contact_person"] = ""
			}
			db.Save(ucf.Totbale, tmp)
		} else {
			//不提取
		}
		if k%1000 == 0 {
			log.Printf("加载数量为：%d，匹配数据量为：%d", k, pipienum)
		}
	}
	log.Println(ucf.User, pipienum, "匹配项目已处理完成")
}

func getKeyMap(m map[string]bool) string {
	ll := []string{}
	for k, _ := range m {
		ll = append(ll, k)
	}
	return strings.Join(ll, ",")
}

// 修复预算
func xiuyusuan() {
	list, _ := db.Find("project_hp", nil, nil, nil, false, -1, -1)
	for _, tmp := range *list {
		total_budget, ok := tmp["total_budget"].(string)
		if ok {
			if strings.Contains(total_budget, ",") {
				log.Println(total_budget)
				total_budget = strings.ReplaceAll(total_budget, ",", "")
			}
			budget, _ := strconv.ParseFloat(total_budget, 64)
			log.Println(total_budget, budget)
			unit, _ := tmp["unit"].(string)
			if strings.Contains(unit, "万") {
				budget = budget * 10000
			}
			//log.Println(total_budget, budget, tmp["_id"])

			db.Update(
				"project_hp",
				map[string]interface{}{"_id": tmp["_id"]},
				map[string]interface{}{"$set": map[string]interface{}{"total_budget_f": budget}},
				true,
				false,
			)

		}
	}
}