jyMicroservices/jyBXBuyer/rpc/model/buyerListBYEs.go

package model

import (
	"encoding/json"
	"fmt"
	IC "jyBXBuyer/rpc/init"
	"jyBXBuyer/rpc/type/bxbuyer"
	"log"
	"strconv"
	"strings"
	"sync"
	"time"

	MC "app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/encrypt"
	elastic "app.yhyue.com/moapp/jybase/es"
	"github.com/zeromicro/go-zero/core/logx"
)

const (
	HasContact = 1 // 采购单位是否有联系方式筛选项 1-有联系方式
	NoContact  = 2 //  无联系方式
)

type BScope struct {
	Keyword         []string `json:"keyword"`
	AdditionalWords []string `json:"additionalWords"`
	ExcludedWords   []string `json:"excludedWords"`
}

// 获取采购单位查询query
func BuyerListQuery(in *bxbuyer.BuyerListReq) (qstr string, CountQstr string) {
	query := `{%s "query":{"bool":{"must":[%s],"must_not": [{"term": {"buyer_name": ""}}],"should":[%s],"minimum_should_match": %d}}}`
	//21.1.20  为和画像保持一致  数据组要求 budget 改成 bidamount
	query_bool_should := `{"bool":{"should":[%s],"minimum_should_match": 1}}`

	bools := []string{}
	musts := []string{}
	musts_should := []string{}
	//省份
	if len(in.Province) > 0 {
		musts_should = append(musts_should, fmt.Sprintf(`{"terms":{"province":["%s"]}}`, strings.Join(in.Province, "\",\"")))
	}
	//城市
	if len(in.City) > 0 {
		musts_should = append(musts_should, fmt.Sprintf(`{"terms":{"city":["%s"]}}`, strings.Join(in.City, "\",\"")))
	}
	if len(musts_should) > 0 {
		musts = append(musts, fmt.Sprintf(query_bool_should, strings.Join(musts_should, ",")))
	}
	//采购单位名称
	if in.BuyerName != "" {
		entNameQuery := fmt.Sprintf(`{"multi_match": {"query": "%s","type": "phrase", "fields": ["name"]}}`, in.BuyerName)
		musts = append(musts, entNameQuery)
	}
	//采购单位类型
	buyerclass := in.BuyerClass
	if len(buyerclass) > 0 {
		Buyerclass := `{"terms":{"buyerclass":[`
		for k, v := range buyerclass {
			if k > 0 {
				Buyerclass += `,`
			}
			Buyerclass += `"` + v + `"`
		}
		Buyerclass += `]}}`
		musts = append(musts, Buyerclass)
	}
	// 采购单位联系方式  0-不限 1-有联系人 2-无联系人
	if in.IsContact != 0 {
		isContact := MC.If(in.IsContact == int64(HasContact), true, false)
		isContactStr := `{"term":{"is_contact":` + fmt.Sprint(isContact) + `}}`
		musts = append(musts, isContactStr)
	}
	boolsNum := 0
	qstr = fmt.Sprintf(query, fmt.Sprintf(`"from":%d,"size": %d,`, (in.PageNum-1)*in.PageSize, in.PageSize), strings.Join(musts, ","), strings.Join(bools, ","), boolsNum)
	CountQstr = fmt.Sprintf(query, "", strings.Join(musts, ","), strings.Join(bools, ","), boolsNum)
	return
}

// 采购单位补充采购规模、项目数量、招标动态数量
func SupplyDataQuery(buyerList []string) (query string) {
	// 查近两年的数据   因为bigmember  BuyerMiniPortrait 查的默认是两年
	q := `{"size":0,"query": { "bool": { "must": [ {"terms": { "buyer": ["` + strings.Join(buyerList, "\",\"") + `"] }},{"range": {"jgtime": {"gte": %d,"lt": %d} }} ]}}, "aggs": { "buyerBuckets": {"terms": {"field": "buyer"
 },"aggs": {"bidAmountCount": {"sum": {"field": "bidamount"}}}}}}`
	start, end := getTimeRange()
	return fmt.Sprintf(q, start.Unix(), end.Unix())
}
func getTimeRange() (st, et time.Time) {
	now := time.Now()
	eYear := now.Year()
	sYear := now.Year() - 2
	//返回默认时间
	sTimeStamp := time.Date(sYear, 1, 1, 0, 0, 0, 0, time.Local)
	eTimeStamp := time.Date(eYear, now.Month(), now.Day(), now.Hour(), now.Minute(), 0, 0, time.Local)

	return sTimeStamp, eTimeStamp

}

const (
	P_INDEX      = "projectset"
	P_TYPE       = "projectset"
	P_redis_time = 15 * 24 * 60 * 60      //redis存15天
	P_redis_key  = "buyerListCache_%d_%d" // 按页存缓存
	BuyerIndex   = "buyer"                // 采购单位index
	BuyerType    = "buyer"
	biddingIndex = "bidding"
	biddingType  = "bidding"
)

// 查询采购单位列表
func GetBuyerList(qstr string, CountQuery string, in *bxbuyer.BuyerListReq, isCache bool) (resp *bxbuyer.BuyerListResp) {
	t1 := time.Now()
	total := elastic.Count(BuyerIndex, BuyerType, CountQuery) // 总数
	fmt.Println("耗时1：", time.Since(t1))
	resp = &bxbuyer.BuyerListResp{
		Data: &bxbuyer.BuyerData{
			Count: total,
			List:  []*bxbuyer.BuyerList{},
		},
	}
	if total == 0 {
		return
	}
	start := time.Now()
	rs := elastic.Get(BuyerIndex, BuyerType, qstr) // 采购单位列表
	fmt.Println("采购单位列表 es get查询耗时", time.Since(start))
	if rs == nil || len(*rs) == 0 {
		return
	}
	var buyerNames []string
	for i := 0; i < len(*rs); i++ {
		tmp := &bxbuyer.BuyerList{
			Buyer:      MC.ObjToString((*rs)[i]["name"]),
			Province:   MC.ObjToString((*rs)[i]["province"]),
			City:       MC.ObjToString((*rs)[i]["city"]),
			BuyerClass: MC.ObjToString((*rs)[i]["buyerclass"]),
		}
		buyerNames = append(buyerNames, tmp.Buyer)
		resp.Data.List = append(resp.Data.List, tmp)
	}
	//省份和城市 是否查询已关注信息 是否查询已领取信息
	//企业信用库qyxy_std 和es buyer库 查询省份和城市
	//客户领取
	t2 := time.Now()
	isRws := map[string]string{}
	if in.IsCheckReceive {
		isRws = IsReceived(buyerNames, in.EntUserId)
	}
	fmt.Println("客户领取耗时：", time.Since(t2))
	//客户关注
	t3 := time.Now()
	isFws := map[string]bool{}
	if in.IsCheckFollow {
		isFws = IsFollowd(buyerNames, in.UserId)
	}
	fmt.Println("采购单位关注耗时：", time.Since(t3))
	for _, bv := range resp.Data.List {
		if in.IsCheckReceive {
			if isRws[bv.Buyer] != "" {
				bv.IsReceived = true
				bv.RecId = isRws[bv.Buyer]
			}
			if isFws[bv.Buyer] {
				bv.IsFollowed = true
			}
		}
	}
	fmt.Println("耗时;", time.Since(t1).Seconds(), "秒--", time.Since(t1).Microseconds())
	return
}

// 补充字段   项目数量 历史联系人数量 采购单位规模
func SupplyBuyerListData(resp *bxbuyer.BuyerListResp) {
	start := time.Now()
	// buyerList
	buyerList := []string{}
	for i := 0; i < len(resp.Data.List); i++ {
		buyerList = append(buyerList, resp.Data.List[i].Buyer)
	}
	t1 := time.Now()
	query := SupplyDataQuery(buyerList) // 项目数量、采购规模
	// 聚合查
	aggs := GetAggs(P_INDEX, P_TYPE, query)
	logx.Info("查询语句：", query)
	fmt.Println("项目数量采购规模查询耗时:", time.Since(t1))
	type BuyerAggStruct struct {
		Buckets []struct {
			Key            string `json:"key,omitempty"`
			Doc_count      int64  `json:"doc_count,omitempty"`
			BidAmountCount struct {
				Value float32 `json:"value,omitempty"`
			} `json:"bidAmountCount"`
		} `json:"buckets"`
	}
	var buyerBuckets = BuyerAggStruct{}
	type supplyDataStruct struct {
		ProjectCount   int64
		BidCount       int64
		BidAmountCount float32
	}
	// 处理成map 用于后面格式化数据
	buyerMap := map[string]supplyDataStruct{}
	if aggs != nil && aggs["buyerBuckets"] != nil {
		bs, err := aggs["buyerBuckets"].MarshalJSON()
		if err != nil {
			resp.ErrCode = -1
			resp.ErrMsg = "获取数据异常"
		} else {
			if len(bs) == 0 {
				resp.ErrMsg = "暂无数据"
			} else {
				err := json.Unmarshal(bs, &buyerBuckets)
				logx.Info(err)
				if len(buyerBuckets.Buckets) > 0 {
					for _, v := range buyerBuckets.Buckets {
						buyerMap[v.Key] = supplyDataStruct{
							BidAmountCount: v.BidAmountCount.Value,
							ProjectCount:   v.Doc_count,
						}
					}
				}
			}
		}
	}
	ch := make(chan int, 10)
	ch2 := make(chan int, 10)
	wg := &sync.WaitGroup{}
	for i := 0; i < len(resp.Data.List); i++ {
		buyer := resp.Data.List[i].Buyer
		// 补充字段
		if supplyData, ok := buyerMap[buyer]; ok {
			resp.Data.List[i].BidAmountCount = supplyData.BidAmountCount
			resp.Data.List[i].ProjectCount = supplyData.ProjectCount
		}
		ch2 <- 1
		wg.Add(1)
		go func(list *bxbuyer.BuyerList, buyer string) {
			defer func() {
				<-ch2
				wg.Done()
			}()
			list.ContactCount = GetProjectContactCount(buyer) // 补充联系人字段
		}(resp.Data.List[i], buyer)
		ch <- 1
		wg.Add(1)
		go func(list *bxbuyer.BuyerList, buyer string) {
			defer func() {
				<-ch
				wg.Done()
			}()
			list.BiddingCount = GetNewBiddingCount(buyer)
		}(resp.Data.List[i], buyer)

	}
	wg.Wait()
	fmt.Println("SupplyBuyerListData 整体耗时：", time.Since(start))
}

func GetProjectContactCount(buyerName string) int64 {
	start := time.Now()
	list := []string{}
	var musts []string
	if buyerName != "" {
		musts = append(musts, fmt.Sprintf(`{"term":{"buyer":"%s"}}`, buyerName))
	}
	if musts == nil || len(musts) == 0 {
		return 0
	}
	searchSql := fmt.Sprintf(`{"query":{"bool":{"must":[%s]}},"_source":["list"],"sort":[{"zbtime":"desc"}],"size":500}`, strings.Join(musts, ","))
	projectList := elastic.Get(P_INDEX, P_TYPE, searchSql)
	logx.Info("GetProjectContactCount esget 耗时", time.Since(start), searchSql)
	if projectList == nil || len(*projectList) == 0 {
		return 0
	}
	//根据联系人和联系方式展示
	//多个项目同一个联系人；只展示最新项目
	//一个项目多个联系人；拆分展示
	repeatContacts := map[string]bool{}
	for _, rowData := range *projectList {
		mapList, ok := rowData["list"].([]interface{})
		if !ok || len(mapList) == 0 {
			continue
		}
		for i := len(mapList) - 1; i >= 0; i-- {
			thisMsg, ok := mapList[i].(map[string]interface{})
			if !ok || len(thisMsg) == 0 {
				continue
			}
			thisPhone, thisPerson := "", ""
			if buyerName != "" {
				if thisPhone, _ = thisMsg["buyertel"].(string); thisPhone != "" {
					thisPerson, _ = thisMsg["buyerperson"].(string)
				}
			}
			if thisPhone == "" { //联系人为空则不展示 dev4.7.3联系人为空展示此记录
				continue
			}
			//一个项目只选取一条公告联系人
			thisAddPerson := false
			//名字中多个联系人拆分
			for _, name := range strings.Split(thisPerson, ",") {
				thisName := strings.TrimSpace(name)
				if thisName == "" && thisAddPerson { //联系人为空则不展示
					continue
				}
				thisAddPerson = true
				repeatKey := fmt.Sprintf("%s_%s", thisName, thisPhone)
				if repeatContacts[repeatKey] {
					continue
				}
				repeatContacts[repeatKey] = true
				list = append(list, thisPhone)
			}
			if thisAddPerson {
				break
			}
		}
	}
	fmt.Println("GetProjectContactCount 单次耗时：", time.Since(start))
	return int64(len(list))
}
func GetNewBiddingCount(buyer string) int64 {
	start := time.Now()
	if buyer == "" {
		return 0
	}
	var mustQuery []string
	st, et := getTimeRange()
	mustQuery = append(mustQuery, fmt.Sprintf(`{"range":{"publishtime":{"gte":%d,"lte":%d}}}`, st.Unix(), et.Unix()))
	mustQuery = append(mustQuery, fmt.Sprintf(`{"term": {"buyer": "%s"}}`, buyer))
	aa := fmt.Sprintf(`{"query":{"bool":{"must":[%s]}}}`, strings.Join(mustQuery, ","))
	count := elastic.Count(biddingIndex, biddingType, aa)
	fmt.Println("GetNewBiddingCount 单次耗时：", time.Since(start))
	return count
}

// 聚合查询
func GetAggs(index, itype, query string) (aggs map[string]json.RawMessage) {
	aggs, _, _ = elastic.GetAggs(index, itype, query)
	return
}

type buyerInfo struct {
	Province string
	City     string
}

// 潜在客户 获取省份和城市
func GetBuyerInfo(buyerNames []string) (infoMap map[string]buyerInfo) {
	var buyerInfoQuery = `{"query": {"bool": {"must": [{"terms": {"%s": [%s]}}],"must_not": [],"should": []}},"from": 0,"size": 50,"sort": []}`
	query := fmt.Sprintf(buyerInfoQuery, "buyer_name", `"`+strings.Join(buyerNames, `","`)+`"`)
	list := *elastic.Get("buyer", "buyer", query)
	if list != nil {
		if len(list) > 0 {
			infoMap = map[string]buyerInfo{}
			for _, v := range list {
				infoMap[v["name"].(string)] = buyerInfo{
					Province: MC.If(v["province"] != nil, MC.ObjToString(v["province"]), "").(string),
					City:     MC.If(v["city"] != nil, MC.ObjToString(v["city"]), "").(string),
				}
			}
		}
	} else {
		logx.Info("采购单位获取地区信息异常")
	}
	return
}

var fc = "follow_customer" //关注客户表
// 采购单位是否作为客户已被关注
func IsFollowd(buyerNames []string, userId string) (isFws map[string]bool) {
	queryMap := map[string]interface{}{
		"userId": userId,
		"name": map[string]interface{}{
			"$in": buyerNames,
		},
	}
	list, ok := IC.Mgo.Find(fc, queryMap, `{"_id":1}`, nil, false, -1, -1)
	if ok && len(*list) > 0 {
		isFws = map[string]bool{}
		for _, lv := range *list {
			if MC.ObjToString(lv["name"]) != "" {
				isFws[MC.ObjToString(lv["name"])] = true
			}
		}
	} else {
		logx.Info("采购单位是否已关注信息异常  or  未查到数据")
	}
	return
}

var (
	Entniche_customer      = "entniche_customer"
	Entniche_user_customer = "entniche_user_customer"
)

// 领取状态
func IsReceived(buyerNames []string, entUserId string) (isRws map[string]string) {
	//新加领取的客户id----保证领取的唯一性
	aa := fmt.Sprintf("SELECT ecn.id,  ecn.name  FROM %s ecn,%s  euu WHERE ecn.id = euu.customer_id AND euu.user_id =? AND ecn.`name` IN  ('%s') AND (euu.source_type =1 or euu.source_type=4)", Entniche_customer, Entniche_user_customer, strings.Join(buyerNames, "','"))
	log.Println(aa)
	receInfos := IC.MainMysql.SelectBySql(fmt.Sprintf("SELECT ecn.id,  ecn.name  FROM %s ecn,%s  euu WHERE ecn.id = euu.customer_id AND euu.user_id =? AND ecn.`name` IN  ('%s') AND (euu.source_type =1 or euu.source_type=4)", Entniche_customer, Entniche_user_customer, strings.Join(buyerNames, "','")), entUserId)
	if receInfos != nil {
		if len(*receInfos) > 0 {
			isRws = map[string]string{}
			for _, rv := range *receInfos {
				if MC.ObjToString(rv["name"]) != "" && strconv.Itoa(MC.IntAll(rv["id"])) != "" {
					isRws[MC.ObjToString(rv["name"])] = encrypt.SE.Encode2HexByCheck(strconv.Itoa(MC.IntAll(rv["id"])))
				}
			}
		}
	} else {
		logx.Info("采购单位是否已领取信息异常")
	}
	return
}

// 是否为空请求
func CheckEmpty(in *bxbuyer.BuyerListReq) bool {
	if in.BuyerName == "" && len(in.BuyerClass) == 0 && len(in.Province) == 0 && len(in.City) == 0 && in.IsContact == 0 {
		return true
	}
	return false
}

//缓存数据查询

// 获取采购单位查询query
func BuyerListRedisCacheQuery(pageNum, pageSize int64) (qstr string, cstr string) {
	query := `{"from":%d,"size":%d,"query":{"bool":{"must":[%s],"must_not": [{"term": {"buyer_name": ""}}],"should":[],"minimum_should_match": %d}}}`
	queryCount := `{"query":{"bool":{"must":[%s],"must_not": [{"term": {"buyer": ""}}],"should":[],"minimum_should_match": %d}}}`
	//21.1.20  为和画像保持一致  数据组要求 budget 改成 bidamount
	musts := []string{}
	boolsNum := 0
	entcustomerClass := `{"terms":{"buyer_name":[`
	for k, v := range IC.C.DefaultBuyerNames {
		if k > 0 {
			entcustomerClass += `,`
		}
		entcustomerClass += `"` + v + `"`
	}
	entcustomerClass += `]}}`
	musts = append(musts, entcustomerClass)
	qstr = fmt.Sprintf(query, (pageNum-1)*pageSize, pageSize, strings.Join(musts, ","), boolsNum)
	cstr = fmt.Sprintf(queryCount, strings.Join(musts, ","), boolsNum)
	logx.Info("qstr:", qstr)
	return
}