datatag/src/util/config.go

package util

import (
	"bytes"
	"io/ioutil"
	"qfw/mongodb"
	qu "qfw/util"
	"qfw/util/elastic"
	"qfw/util/mysql"
	"qfw/util/redis"
	"sort"
	"util/chain-zhang/pinyin"
	mgo "util/mgodb"

	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
)

var (
	Sysconfig       map[string]interface{} //配置文件
	Mgo             *mongodb.MongodbSim
	MgoCus          *mongodb.MongodbSim //企业服务库
	MgoEn           *mongodb.MongodbSim
	EsIndex, EsType string
	MgoEnC          string
	Subday          float64
	PreviewHref     string //数据预览地址
	CustomerApi     string
	LatestId        = ""            //起始id
	MgoTag          *mgo.MongodbSim //标签库连接
	MgoSave         *mgo.MongodbSim //数据保存库连接
	MgoBuyer        *mgo.MongodbSim //医院等级信息
	MgoEnps         *mgo.MongodbSim //企业信息
	MgoExtract      *mgo.MongodbSim //抽取
	MgoBidding      *mgo.MongodbSim //bidding
	BiddingColl     string
	SaveColl        string
	HospColl        string
	BuyerEntColl    string
	EnpsColl        string
	Es              *elastic.Elastic //es
	Index           string
	Itype           string
	TaskTime        int64 //定时任务时间
	//历史数据
	SId             string
	EId             string
	CustomerName    string
	SaveCollProject string
	SaveCollbid     string
	SaveUserMail    string
	ExtractColl     string
	JyMysql         *mysql.Mysql
)

var (
	TopTypeArr    []string                  //公告一级分类
	SubTypeArr    []string                  //公告二级分类
	Province      []string                  //省
	ProvinceCitys map[string][]string       //省:[市1,市2]
	CityDistricts map[string][]string       //市:[区1,区2]
	BuyerClass    []string                  //采购单位行业
	BuyerClassMap map[string][]string       //采购单位行业带拼音字母
	MatchTypeMap  *[]map[string]interface{} //匹配方式
	MatchTypeMap2 map[string]interface{}    //匹配方式
	MatchTypeMap3 *[]map[string]interface{} //匹配方式
	ExistFiled    *[]map[string]interface{} //存在的字段
	ScopeClassMap *[]map[string]interface{} //公告行业
	TagFieldMap   *[]map[string]interface{} //标签属性值
	TaskTypeMap   *[]map[string]interface{} //任务类型
	BuryClassType map[string]interface{}
	ProvinceMap   map[string]interface{}
)

func InitMgoPool() {
	Mgo = &mongodb.MongodbSim{
		MongodbAddr: qu.ObjToString(Sysconfig["mgodb"]),
		Size:        qu.IntAll(Sysconfig["dbsize"]),
		DbName:      qu.ObjToString(Sysconfig["dbname"]),
	}
	Mgo.InitPool()

	customer := Sysconfig["customer"].(map[string]interface{})
	CustomerApi = qu.ObjToString(customer["api"])
	MgoCus = &mongodb.MongodbSim{
		MongodbAddr: qu.ObjToString(customer["mgodb"]),
		Size:        qu.IntAll(customer["dbsize"]),
		DbName:      qu.ObjToString(customer["dbname"]),
	}
	MgoCus.InitPool()
}

func initMgoEn() {
	MgoEn = &mongodb.MongodbSim{
		MongodbAddr: qu.ObjToString(Sysconfig["mgodben"]),
		Size:        qu.IntAll(Sysconfig["dbsize"]),
		DbName:      qu.ObjToString(Sysconfig["dbnameen"]),
	}
	MgoEnC = qu.ObjToString(Sysconfig["mongoenc"])
	MgoEn.InitPool()
}

func InitOther() {
	initCitys()
	initInfoType()
	initBuyerClass()
	initMatchType()
	initExitField()
	initScopeClass()
	initTaskType()
	initEs()
	// initMgoEn()
	Subday = qu.Float64All(Sysconfig["subday"])
	PreviewHref = qu.ObjToString(Sysconfig["preview_href"])
	initTagField()
	initdb()
	initBuryClassType()
	initProvince()
}

func initCitys() {
	//map初始化
	if ProvinceCitys == nil {
		ProvinceCitys = make(map[string][]string)
	}
	if CityDistricts == nil {
		CityDistricts = make(map[string][]string)
	}
	datas, _ := Mgo.Find("code_city", `{}`, `{"_id":1}`, `{}`, false, -1, -1)
	for k, data := range *datas {
		brief := data["brief"].(string)
		if k != 0 {
			Province = append(Province, brief)
		}
		if data["citys"] != nil {
			citys := data["citys"].([]interface{})
			citytmp := []string{}
			for _, city := range citys {
				cityMap := city.(map[string]interface{})
				for cname, districts := range cityMap {
					citytmp = append(citytmp, cname)
					tmp := districts.([]interface{})
					districtarr := qu.ObjArrToStringArr(tmp)
					CityDistricts[cname] = districtarr
				}
			}
			ProvinceCitys[brief] = citytmp
		}
	}
	Province = append(Province, qu.ObjToString((*datas)[0]["brief"]))
}

func initInfoType() {
	datas, _ := Mgo.Find("code_infotype", `{}`, `{"_id":1}`, `{}`, false, -1, -1)
	for _, data := range *datas {
		name := data["name"].(string)
		TopTypeArr = append(TopTypeArr, name)
		child := qu.ObjArrToStringArr(data["child"].([]interface{}))
		SubTypeArr = append(SubTypeArr, child...)
	}
	//qu.Debug(InfoTypeArr, InfoTypeMap)
}

func initBuyerClass() {
	if BuyerClassMap == nil {
		BuyerClassMap = make(map[string][]string)
	}
	datas, _ := Mgo.Find("code_buyerclass", `{}`, `{"name":1}`, `{}`, false, -1, -1)
	for _, data := range *datas {
		name := data["name"].(string)
		BuyerClass = append(BuyerClass, name)
	}
	sort.Sort(ByPinyin(BuyerClass))
	for _, name := range BuyerClass {
		str, _ := pinyin.New(name).Mode(pinyin.InitialsInCapitals).Convert()
		//fmt.Println(str, err)
		zimu := str[0:1]
		BuyerClassMap[zimu] = append(BuyerClassMap[zimu], name)
	}

}

func initMatchType() {
	//map初始化
	if MatchTypeMap2 == nil {
		MatchTypeMap2 = make(map[string]interface{})
	}
	MatchTypeMap, _ = Mgo.Find("code_matchtype", `{}`, `{"_id":1}`, `{}`, false, -1, -1)
	MatchTypeMap3, _ = Mgo.Find("code_matchtype", `{"type": 1}`, nil, nil, false, -1, -1)
	for _, d := range *MatchTypeMap {
		code := qu.ObjToString(d["code"])
		name := qu.ObjToString(d["name"])
		MatchTypeMap2[code] = name
	}
}

func initExitField() {
	ExistFiled, _ = Mgo.Find("code_field", `{}`, `{"_id":1}`, `{}`, false, -1, -1)
	for _, data := range *ExistFiled {
		str, _ := pinyin.New(data["name"].(string)).Mode(pinyin.InitialsInCapitals).Convert()
		//fmt.Println(str, err)
		//zimu := str[0:1]
		data["zimu"] = str
	}

	for i := 0; i < len(*ExistFiled); i++ {
		for j := 0; j < len(*ExistFiled)-i-1; j++ {
			if (*ExistFiled)[j]["zimu"].(string) > (*ExistFiled)[j+1]["zimu"].(string) {
				(*ExistFiled)[j], (*ExistFiled)[j+1] = (*ExistFiled)[j+1], (*ExistFiled)[j]
			}
		}
	}
	//for _, data := range *datas {
	//	name := data["name"].(string)
	//	ExistFiled = append(ExistFiled, name)
	//}
}

func initScopeClass() {
	ScopeClassMap, _ = Mgo.Find("code_scopeclass", `{}`, `{"_id": 1}`, `{}`, false, -1, -1)
}

func initTaskType() {
	TaskTypeMap, _ = Mgo.Find("code_task", `{}`, `{"_id": 1}`, `{}`, false, -1, -1)
}

func initEs() {
	EsIndex, EsType = qu.ObjToString(Sysconfig["elasticsearch_index"]), qu.ObjToString(Sysconfig["elasticsearch_type"])
	elastic.InitElasticSize(qu.ObjToString(Sysconfig["elasticsearch"]), qu.IntAllDef(qu.Int64All(Sysconfig["elasticPoolSize"]), 30))
}

func initTagField() {
	TagFieldMap, _ = Mgo.Find("code_tagfield", `{}`, `{"_id": 1}`, `{}`, false, -1, -1)
}

func initBuryClassType() {
	infoType := JyMysql.SelectBySql("SELECT id,name FROM infotype")
	BuryClassType = make(map[string]interface{})
	for _, val := range *infoType {
		k := qu.ObjToString(val["name"])
		BuryClassType[k] = val["id"]
	}
}

func initProvince() {
	proArr := JyMysql.SelectBySql("SELECT id,name FROM province")
	ProvinceMap = make(map[string]interface{})
	for _, val := range *proArr {
		k := qu.ObjToString(val["name"])
		ProvinceMap[k] = val["id"]
	}
}

func initdb() {
	//mgo save
	save := Sysconfig["save"].(map[string]interface{})
	SaveColl = qu.ObjToString(save["coll"])
	SaveCollProject = qu.ObjToString(save["coll_project"])
	SaveCollbid = qu.ObjToString(save["coll_bid"])
	SaveUserMail = qu.ObjToString(save["coll_usermail"])
	MgoSave = &mgo.MongodbSim{
		MongodbAddr: qu.ObjToString(save["addr"]),
		DbName:      qu.ObjToString(save["db"]),
		Size:        qu.IntAllDef(save["size"], 15),
	}
	MgoSave.InitPool()
	//mgo buyerinfo
	buyerinfo := Sysconfig["buyerinfo"].(map[string]interface{})
	HospColl = qu.ObjToString(buyerinfo["hospcoll"])
	BuyerEntColl = qu.ObjToString(buyerinfo["buyerentcoll"])
	MgoBuyer = &mgo.MongodbSim{
		MongodbAddr: qu.ObjToString(buyerinfo["addr"]),
		DbName:      qu.ObjToString(buyerinfo["db"]),
		Size:        qu.IntAllDef(buyerinfo["size"], 15),
		UserName:    qu.ObjToString(buyerinfo["username"]),
		Password:    qu.ObjToString(buyerinfo["password"]),
		ReplSet:     qu.ObjToString(buyerinfo["replSet"]),
	}
	MgoBuyer.InitPool()
	//mgo enterprise
	enterprise := Sysconfig["enterprise"].(map[string]interface{})
	EnpsColl = qu.ObjToString(enterprise["coll"])
	MgoEnps = &mgo.MongodbSim{
		MongodbAddr: qu.ObjToString(enterprise["addr"]),
		DbName:      qu.ObjToString(enterprise["db"]),
		Size:        qu.IntAllDef(enterprise["size"], 15),
		UserName:    qu.ObjToString(buyerinfo["username"]),
		Password:    qu.ObjToString(buyerinfo["password"]),
		ReplSet:     qu.ObjToString(buyerinfo["replSet"]),
	}
	MgoEnps.InitPool()
	extract := Sysconfig["extract"].(map[string]interface{})
	ExtractColl = qu.ObjToString(extract["coll"])
	MgoExtract = &mgo.MongodbSim{
		MongodbAddr: qu.ObjToString(extract["addr"]),
		DbName:      qu.ObjToString(extract["db"]),
		Size:        qu.IntAllDef(extract["size"], 15),
	}
	MgoExtract.InitPool()

	//bidding库
	bidding := Sysconfig["bidding_mgo"].(map[string]interface{})
	BiddingColl = qu.ObjToString(bidding["coll"])
	MgoBidding = &mgo.MongodbSim{
		MongodbAddr: qu.ObjToString(bidding["addr"]),
		DbName:      qu.ObjToString(bidding["db"]),
		Size:        qu.IntAll(bidding["size"]),
		UserName:    qu.ObjToString(bidding["username"]),
		Password:    qu.ObjToString(bidding["password"]),
		ReplSet:     qu.ObjToString(bidding["replSet"]),
	}
	MgoBidding.InitPool()

	//es
	es := Sysconfig["es"].(map[string]interface{})
	Es = &elastic.Elastic{
		S_esurl: qu.ObjToString(es["addr"]),
		I_size:  qu.IntAllDef(es["pool"], 15),
	}
	Es.InitElasticSize()
	redis.InitRedisBySize(qu.ObjToString(Sysconfig["redis_addrs"]), 100, 30, 300)
	Index = qu.ObjToString(es["index"])
	Itype = qu.ObjToString(es["itype"])
	jyMysql := qu.ObjToMap(Sysconfig["jyMysql"])
	JyMysql = &mysql.Mysql{
		Address:  (*jyMysql)["address"].(string),
		UserName: (*jyMysql)["username"].(string),
		PassWord: (*jyMysql)["password"].(string),
		DBName:   (*jyMysql)["dbName"].(string),
	}
	JyMysql.Init()
}

type ByPinyin []string

func (s ByPinyin) Len() int      { return len(s) }
func (s ByPinyin) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s ByPinyin) Less(i, j int) bool {
	a, _ := UTF82GBK(s[i])
	b, _ := UTF82GBK(s[j])
	bLen := len(b)
	for idx, chr := range a {
		if idx > bLen-1 {
			return false
		}
		if chr != b[idx] {
			return chr < b[idx]
		}
	}
	return true
}

//UTF82GBK : transform UTF8 rune into GBK byte array
func UTF82GBK(src string) ([]byte, error) {
	GB18030 := simplifiedchinese.All[0]
	return ioutil.ReadAll(transform.NewReader(bytes.NewReader([]byte(src)), GB18030.NewEncoder()))
}