data_ai/ul/init.go

package ul

import (
	"bytes"
	"encoding/json"
	"fmt"
	log "github.com/donnie4w/go-logger/logger"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"io/ioutil"
	qu "jygit.jydev.jianyu360.cn/data_processing/common_utils"
	"net/http"
	"time"
)

func InitGlobalVar() {
	qu.ReadConfig(&SysConfig) //加载配置文件
	initMgo()
	initPCD()
	initOther()
}
func InitToolVar() {
	qu.ReadConfig("./tool.json", &ToolConfig) //加载配置文件
	if len(ToolConfig) == 0 || ToolConfig == nil {
		log.Fatal("缺少tool.json文件")
	}
	initToolMgo()
	initPCD()
	initOther()
}

// 其它属性
func initOther() {
	//glm-4-air glm-4-flash
	FlashModel = "glm-4-air"
	//ModelType = "DeepSeek"
	ModelType = "Flash"
	MaxUdp = qu.IntAllDef(SysConfig["udp_max"], 10000)
}

// 初始化mgo
func initMgo() {
	Reading = qu.IntAll(SysConfig["reading"])
	if Reading == 0 {
		Reading = 500
	}
	Bid_Name, Ext_Name = qu.ObjToString(SysConfig["bid_name"]), qu.ObjToString(SysConfig["ext_name"])
	//源数据
	b_cfg := *qu.ObjToMap(SysConfig["b_mgo"])
	b_local := b_cfg["local"].(bool)
	b_addr := qu.ObjToString(b_cfg["addr"])
	if b_local {
		b_addr = qu.ObjToString(b_cfg["l_addr"])
	}
	BidMgo = &MongodbSim{
		MongodbAddr: b_addr,
		DbName:      qu.ObjToString(b_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(b_cfg["username"]),
		Password:    qu.ObjToString(b_cfg["password"]),
	}
	if b_local {
		BidMgo.InitPoolDirect()
	} else {
		BidMgo.InitPool()
	}

	//源数据
	s_cfg := *qu.ObjToMap(SysConfig["s_mgo"])
	s_local := s_cfg["local"].(bool)
	s_addr := qu.ObjToString(s_cfg["addr"])
	if s_local {
		s_addr = qu.ObjToString(s_cfg["l_addr"])
	}
	SourceMgo = &MongodbSim{
		MongodbAddr: s_addr,
		DbName:      qu.ObjToString(s_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(s_cfg["username"]),
		Password:    qu.ObjToString(s_cfg["password"]),
	}
	if s_local {
		SourceMgo.InitPoolDirect()
	} else {
		SourceMgo.InitPool()
	}

	//企业数据
	qy_cfg := *qu.ObjToMap(SysConfig["qy_mgo"])
	qy_local := qy_cfg["local"].(bool)
	qy_addr := qu.ObjToString(qy_cfg["addr"])
	if qy_local {
		qy_addr = qu.ObjToString(qy_cfg["l_addr"])
	}
	QyxyMgo = &MongodbSim{
		MongodbAddr: qy_addr,
		DbName:      qu.ObjToString(qy_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(qy_cfg["username"]),
		Password:    qu.ObjToString(qy_cfg["password"]),
	}
	if qy_local {
		QyxyMgo.InitPoolDirect()
	} else {
		QyxyMgo.InitPool()
	}
}

// 初始化mgo
func initToolMgo() {
	Reading, Ext_Name = qu.IntAll(ToolConfig["reading"]), qu.ObjToString(ToolConfig["ext_name"])
	if Reading == 0 {
		Reading = 500
	}
	//源数据
	b_cfg := *qu.ObjToMap(ToolConfig["b_mgo"])
	b_local := b_cfg["local"].(bool)
	b_addr := qu.ObjToString(b_cfg["addr"])
	if b_local {
		b_addr = qu.ObjToString(b_cfg["l_addr"])
	}
	BidMgo = &MongodbSim{
		MongodbAddr: b_addr,
		DbName:      qu.ObjToString(b_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(b_cfg["username"]),
		Password:    qu.ObjToString(b_cfg["password"]),
	}
	if b_local {
		BidMgo.InitPoolDirect()
	} else {
		BidMgo.InitPool()
	}

	//源数据
	s_cfg := *qu.ObjToMap(ToolConfig["s_mgo"])
	s_local := s_cfg["local"].(bool)
	s_addr := qu.ObjToString(s_cfg["addr"])
	if s_local {
		s_addr = qu.ObjToString(s_cfg["l_addr"])
	}
	SourceMgo = &MongodbSim{
		MongodbAddr: s_addr,
		DbName:      qu.ObjToString(s_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(s_cfg["username"]),
		Password:    qu.ObjToString(s_cfg["password"]),
	}
	if s_local {
		SourceMgo.InitPoolDirect()
	} else {
		SourceMgo.InitPool()
	}

	//企业数据
	qy_cfg := *qu.ObjToMap(ToolConfig["qy_mgo"])
	qy_local := qy_cfg["local"].(bool)
	qy_addr := qu.ObjToString(qy_cfg["addr"])
	if qy_local {
		qy_addr = qu.ObjToString(qy_cfg["l_addr"])
	}
	QyxyMgo = &MongodbSim{
		MongodbAddr: qy_addr,
		DbName:      qu.ObjToString(qy_cfg["dbname"]),
		Size:        10,
		UserName:    qu.ObjToString(qy_cfg["username"]),
		Password:    qu.ObjToString(qy_cfg["password"]),
	}
	if qy_local {
		QyxyMgo.InitPoolDirect()
	} else {
		QyxyMgo.InitPool()
	}
}

// 标准化省市区···
func initPCD() {
	S_ProvinceDict = make(map[string][]S_Province, 0)
	S_CityDict = make(map[string][]S_City, 0)
	S_DistrictDict = make(map[string][]S_District, 0)
	q := map[string]interface{}{
		"town_code": map[string]interface{}{
			"$exists": 0,
		},
	}
	dataArr, _ := QyxyMgo.Find("address_jy_2022", q, nil, nil)
	for _, tmp := range dataArr {
		district_code := qu.IntAll(tmp["district_code"])
		city_code := qu.IntAll(tmp["city_code"])
		if district_code > 0 {
			province := qu.ObjToString(tmp["province"])
			city := qu.ObjToString(tmp["city"])
			district := qu.ObjToString(tmp["district"])
			data := S_District{province, city, district}
			if S_DistrictDict[district] == nil {
				S_DistrictDict[district] = []S_District{data}
			} else {
				arr := S_DistrictDict[district]
				arr = append(arr, data)
				S_DistrictDict[district] = arr
			}
		} else {
			if city_code > 0 {
				province := qu.ObjToString(tmp["province"])
				city := qu.ObjToString(tmp["city"])
				data := S_City{province, city}
				if S_CityDict[city] == nil {
					S_CityDict[city] = []S_City{data}
				} else {
					arr := S_CityDict[city]
					arr = append(arr, data)
					S_CityDict[city] = arr
				}
			} else {
				province := qu.ObjToString(tmp["province"])
				data := S_Province{province}
				if S_ProvinceDict[province] == nil {
					S_ProvinceDict[province] = []S_Province{data}
				} else {
					arr := S_ProvinceDict[province]
					arr = append(arr, data)
					S_ProvinceDict[province] = arr
				}
			}
		}
	}
	log.Debug(fmt.Sprintf("城市配置加载完毕...省~%d 市~%d 区~%d", len(S_ProvinceDict), len(S_CityDict), len(S_DistrictDict)))
}

// 加载规则...
func InitPnameRules() {
	//q := map[string]interface{}{"s_field": "projectname", "pid": "5cdd1c70e138234848c1d776", "delete": false}
	//rs, _ := ExtMgo.Find("rule_logicback", q, bson.M{"_id": 1}, nil)
	//for _, v := range rs {
	//	s_rule := qu.ObjToString(v["s_rule"])
	//	tmp := strings.Split(s_rule, "__")
	//	pattern := tmp[0]
	//	if len(tmp) == 2 {
	//		reg := &ExtReg{Reg: regexp.MustCompile(pattern), Replace: tmp[1]}
	//		RulesPname = append(RulesPname, reg)
	//	} else {
	//		reg := &ExtReg{Reg: regexp.MustCompile(pattern), Replace: ""}
	//		RulesPname = append(RulesPname, reg)
	//	}
	//}
	//log.Debug("加载项目名称规则...", len(RulesPname))
}

func IsMarkInterfaceMap(t interface{}) []map[string]interface{} {
	p_list := []map[string]interface{}{}
	if list_3, ok_3 := t.([]map[string]interface{}); ok_3 {
		p_list = list_3
		return p_list
	}

	if yl_list_1, ok_1 := t.(primitive.A); ok_1 {
		p_list = qu.ObjArrToMapArr(yl_list_1)
	} else {
		if yl_list_2, ok_2 := t.([]interface{}); ok_2 {
			p_list = qu.ObjArrToMapArr(yl_list_2)
		}
	}
	return p_list
}

func PostMarkDownText(html string) string {
	url := "http://172.17.162.35:18811/md"
	if IsLocal {
		//url = "http://172.17.0.11:8888/md"
		url = "http://192.168.3.13:8888/md"
	}
	// 创建请求数据
	jsonData, err := json.Marshal(map[string]interface{}{"html": html})
	if err != nil {
		return ""
	}
	// 创建HTTP请求
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return ""
	}
	// 设置请求头
	req.Header.Set("Content-Type", "application/json")
	client := &http.Client{}
	client.Timeout = 60 * time.Second
	resp, err := client.Do(req)
	if err != nil {
		return ""
	}
	defer resp.Body.Close()

	// 读取响应体
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return ""
	}
	info := map[string]interface{}{}
	err = json.Unmarshal(body, &info)
	if err != nil {
		return ""
	}
	return qu.ObjToString(info["result"])
}

func PostPurchasingList(data map[string]interface{}) map[string]interface{} {
	url := "http://172.17.162.35:18787/"
	if IsLocal {
		url = "http://172.17.0.153:18787/"
	}
	jsonData, err := json.Marshal(data)
	if err != nil {
		return map[string]interface{}{}
	}
	// 创建HTTP请求
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return map[string]interface{}{}
	}
	// 设置请求头
	req.Header.Set("Content-Type", "application/json")
	client := &http.Client{}
	client.Timeout = 180 * time.Second
	resp, err := client.Do(req)
	if err != nil {
		return map[string]interface{}{}
	}
	defer resp.Body.Close()
	// 读取响应体
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return map[string]interface{}{}
	}
	info := map[string]interface{}{}
	err = json.Unmarshal(body, &info)
	if err != nil {
		return map[string]interface{}{}
	}
	return info
}