application/api/internal/service/owner.go

package service

import (
	"app.yhyue.com/moapp/jybase/encrypt"
	"context"
	"encoding/json"
	"fmt"
	"sort"
	"strings"
	"time"

	"app.yhyue.com/moapp/jybase/common"
	elastic "app.yhyue.com/moapp/jybase/es"
	. "bp.jydev.jianyu360.cn/CRM/application/api/common"
	"bp.jydev.jianyu360.cn/CRM/application/entity"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/shopspring/decimal"
	"github.com/zeromicro/go-zero/core/logx"
)

const (
	EntINDEX = "ent_info"
	EntTYPE  = "ent_info"
)

type OwnerService struct {
	PartyA           string
	Supplier         string
	Heterotophy      string
	Intermediary     string
	Agency           string
	SearchEntName    string
	SourceType       string
	ProcessingStatus string
	Area             string
	PositionId       int64
	PageIndex        int64
	PageSize         int64
	BuyerId          string
	BuyerName        string
	WinnerId         string
	WinnerName       string
	CooperateType    string
	EntAccountId     int64
}

type BuyerProject struct {
	BuyerId          string
	BuyerName        string
	Project          ProjectEntity
	IsMonitor        bool
	IsCreateCustomer bool
	IsIgnore         bool
	Area             string
	Zbtime           int64
}
type ProjectEntity struct {
	Number          int64
	zbtime          int64
	EstimatedAmount int64
	Connections     []map[string]interface{}
}
type Recommend struct {
	buyerId string `ch:"buyer_id"`
	buyer   string `ch:"buyer"`
}
type Project struct {
	BuyerId    string          `ch:"buyer_id"`
	Area       string          `ch:"area"`
	GroupCount uint64          `ch:"group_count"`
	Zbtime     int64           `ch:"zbtime"`
	Money      decimal.Decimal `ch:"money"`
}

func (t *OwnerService) OwnerlList() map[string]interface{} {
	//先查询采购单位列表
	startTime := time.Now().Unix()
	dataMap := &map[string]map[string]interface{}{}
	projectMap := &map[string]map[string]interface{}{}
	if t.PartyA != "" || t.Supplier != "" || t.Heterotophy != "" || t.Intermediary != "" || t.Agency != "" {
		dataMap = BuyerList(t.PartyA, t.Supplier, t.Heterotophy, t.Intermediary, t.Agency)
		//处理状态初始化
		if t.ProcessingStatus != "" {
			ProcessingStatusInit(t.PositionId, dataMap, t.ProcessingStatus)
		}
		//监控状态处理
		MonitorStatusInit(t.PositionId, dataMap, t.SourceType)
		//项目数量查询
		buyerArr := []string{}
		for _, value := range *dataMap {
			buyerArr = append(buyerArr, fmt.Sprintf(`"%s"`, gconv.String(value["buyerName"])))
		}
		//项目数量处理
		projectMap, _ = ProjectHandle(buyerArr, t.PositionId, t.SearchEntName, t.Area, t.SourceType, t.ProcessingStatus)
	} else if t.SearchEntName != "" {
		//1 只看转介绍成功率高2只看已监控的
		//先查找采购单位数据
		projectMap, dataMap = ProjectHandle([]string{}, t.PositionId, t.SearchEntName, t.Area, t.SourceType, t.ProcessingStatus)
		a7 := time.Now().Unix()
		fmt.Println("es用时", a7-startTime)
		if t.ProcessingStatus != "" {
			ProcessingStatusInit(t.PositionId, dataMap, t.ProcessingStatus)
		}
		a8 := time.Now().Unix()
		fmt.Println("状态用时", a8-a7)
		//监控状态处理
		MonitorStatusInit(t.PositionId, dataMap, t.SourceType)
		a9 := time.Now().Unix()
		fmt.Println("监控用时", a9-a8)
	}

	endTime := time.Now().Unix()
	fmt.Println("用时时间：", endTime-startTime)
	if len(*dataMap) == 0 {
		return map[string]interface{}{}
	}
	//采购单位和项目合并
	a1 := time.Now().Unix()
	returnData, connectionsNumber, highSuccessNumber, monitorNumber := BuyerProjectMerge(dataMap, projectMap, t.SourceType)
	a2 := time.Now().Unix()
	fmt.Println("组合数据", a2-a1)
	//数组排序
	//分页数据处理
	if t.PageSize == 0 {
		t.PageSize = 10
	}
	if t.PageIndex == 0 {
		t.PageIndex = 1
	}
	startIndex := (t.PageIndex - 1) * t.PageSize
	endIndex := t.PageIndex * t.PageSize
	sort.Slice(returnData, func(i, j int) bool {
		return returnData[i].Zbtime < returnData[j].Zbtime
	})
	if startIndex < gconv.Int64(len(returnData)) {
		if endIndex > gconv.Int64(len(returnData)) {
			endIndex = gconv.Int64(len(returnData))
		}
		returnData = returnData[startIndex:endIndex]
	} else {
		return map[string]interface{}{}
	}
	buyerIdArr := []string{}
	for _, value := range returnData {
		if value.BuyerId != "" {
			buyerIdArr = append(buyerIdArr, fmt.Sprintf("'%s'", value.BuyerId))
		}

	}
	//可介绍业主人脉处理
	a3 := time.Now().Unix()
	routeList := ConnectionsHandle(buyerIdArr, t.PositionId, false)
	a4 := time.Now().Unix()
	fmt.Println("组合数1111据", a4-a3)
	for _, v := range routeList {
		buyerId := gconv.String(v["a_id"])
		for i, v1 := range returnData {
			aBuyerId := v1.BuyerId
			if buyerId == aBuyerId {
				//组装数据
				returnData[i].Project.Connections = append(returnData[i].Project.Connections, v)
			}
		}
	}
	//返回数据组装
	return map[string]interface{}{
		"connectionsNumber": connectionsNumber,
		"highSuccessNumber": highSuccessNumber,
		"monitorNumber":     monitorNumber,
		"list":              returnData,
	}
}

// 可介绍业主人脉列表
func ConnectionsHandle(buyerArr []string, positionId int64, isAll bool) []map[string]interface{} {
	returnData := []map[string]interface{}{}
	a1 := time.Now().Unix()
	//中间人
	returnData = FindMiddleman(buyerArr, positionId, returnData)
	a2 := time.Now().Unix()
	fmt.Println("中间人", a2-a1)
	if isAll && len(returnData) > 0 {
		return returnData
	}
	//采购单位 投资关系  管辖关系
	//采购单位
	a3 := time.Now().Unix()
	returnData = Findfirstparty(buyerArr, returnData)
	a4 := time.Now().Unix()
	fmt.Println("采购单位", a4-a3)
	if isAll && len(returnData) > 0 {
		return returnData
	}
	a5 := time.Now().Unix()

	returnData = Findwinner(buyerArr, returnData)
	a6 := time.Now().Unix()
	logx.Info("供应商", a6-a5)
	return returnData
}

// 供应商处理
func Findwinner(buyerArr []string, returnData []map[string]interface{}) []map[string]interface{} {
	//供应商  采购单位 供应商     招标代理机构  采购单位  招标代理机构  需要计算合作次数
	winnerSql := fmt.Sprintf(`select
		DISTINCT 
			zbtime,
			project_id,
			project_name,
			buyer_id,
			buyer,
			agency_id,
			agency,
			winner_id,
			winner
	from
			transaction_info     
	where
		buyer_id in (%s)`, strings.Join(buyerArr, ","))
	winnerArr := SupplierFindConnectionsHandle(winnerSql)
	if winnerArr != nil && len(winnerArr) > 0 {
		//企业联系人处理
		entIdArr := []string{}
		for _, v := range winnerArr {
			if v.WinnerId != "" {
				entIdArr = append(entIdArr, fmt.Sprintf("'%s'", v.WinnerId))
			}
			if v.Agency_id != "" {
				entIdArr = append(entIdArr, fmt.Sprintf("'%s'", v.Agency_id))
			}
		}
		personMap := map[string]string{}
		entNameMap := map[string]string{}
		if len(entIdArr) > 0 {
			personSql := fmt.Sprintf(`select  id,name as personName from   ent_contact    where   id in (%s)  ORDER by  name`, strings.Join(entIdArr, ","))
			personArr := PersonFindConnectionsHandle(personSql)
			//联系人处理
			for _, v := range personArr {
				personMap[v.Id] = v.PersonName
			}
			entSql := fmt.Sprintf(`select  id ,company_name as personName  from  ent_info where   id in (%s)  ORDER by  company_name`, strings.Join(entIdArr, ","))
			entNameArr := PersonFindConnectionsHandle(entSql)
			for _, v := range entNameArr {
				entNameMap[v.Id] = v.PersonName
			}
		}

		winnerMap := map[string]map[string]interface{}{}
		agencyMap := map[string]map[string]interface{}{}
		agencyIdMap := map[string]bool{}
		for _, m := range winnerArr {
			buyerId := m.Buyer_id
			winner := m.Winner
			buyer := m.Buyer
			winnerId := m.WinnerId
			agency := m.Agency
			agencyId := m.Agency_id
			projectId := encrypt.EncodeArticleId2ByCheck(m.Project_id)
			projectName := m.Project_name
			zbtime := m.Zbtime
			key := fmt.Sprintf("%s_%s", buyerId, winnerId)
			if winnerId != "" {
				if _, ok := winnerMap[key]; ok {
					data := winnerMap[key]
					data["count"] = gconv.Int64(data["data"]) + 1
					dataList := gconv.Maps(data["list"])
					dataList = append(dataList, map[string]interface{}{
						"zbtime":      zbtime,
						"projectId":   projectId,
						"projectName": projectName,
					})
					data["list"] = dataList
					winnerMap[key] = data
				} else {
					winnerMap[key] = map[string]interface{}{
						"b_id":       winnerId,
						"b_name":     winner,
						"a_name":     buyer,
						"a_id":       buyerId,
						"sourceType": "supplier",
						"personName": gconv.String(personMap[winnerId]),
						"count":      1,
						"list": []map[string]interface{}{
							{
								"zbtime":      zbtime,
								"entName":     winner,
								"projectId":   projectId,
								"projectName": projectName,
							},
						},
					}
				}
			}
			if agencyId != "" && buyerId != "" && projectId != "" {
				key = fmt.Sprintf("%s_%s_%s", buyerId, agencyId, projectId)
				key1 := fmt.Sprintf("%s_%s", buyerId, agencyId, projectId)
				if _, ok := agencyIdMap[key]; ok {
					data := agencyMap[key]
					data["count"] = gconv.Int64(data["data"]) + 1
					dataList := gconv.Maps(data["list"])
					dataList = append(dataList, map[string]interface{}{
						"zbtime":      zbtime,
						"projectId":   projectId,
						"projectName": projectName,
					})
					data["list"] = dataList
					agencyMap[key] = data
				} else {
					agencyIdMap[key] = true
					agencyMap[key1] = map[string]interface{}{
						"b_id":       agencyId,
						"b_name":     agency,
						"a_name":     buyer,
						"a_id":       buyerId,
						"sourceType": "agency",
						"count":      1,
						"personName": gconv.String(personMap[agencyId]),
						"list": []map[string]interface{}{
							{
								"zbtime":      zbtime,
								"projectId":   projectId,
								"projectName": projectName,
							},
						},
					}
				}
			}

		}
		for _, m := range winnerMap {
			returnData = append(returnData, map[string]interface{}{
				"b_id":         gconv.String(m["b_id"]),
				"b_name":       gconv.String(m["b_name"]),
				"a_name":       gconv.String(m["a_name"]),
				"a_id":         gconv.String(m["a_id"]),
				"sourceType":   gconv.String(m["sourceType"]),
				"relationship": gconv.String(m["relationship"]),
				"count":        gconv.Int64(m["count"]),
				"list":         m["list"],
			})
		}
		for _, m := range agencyMap {
			returnData = append(returnData, map[string]interface{}{
				"b_id":         gconv.String(m["b_id"]),
				"b_name":       gconv.String(m["b_name"]),
				"a_name":       gconv.String(m["a_name"]),
				"a_id":         gconv.String(m["a_id"]),
				"sourceType":   gconv.String(m["sourceType"]),
				"relationship": gconv.String(m["relationship"]),
				"count":        gconv.Int64(m["count"]),
				"list":         m["list"],
			})
		}
	}
	return returnData
}

// 中间人查询
func FindMiddleman(buyerArr []string, positionId int64, returnData []map[string]interface{}) []map[string]interface{} {
	//中间人  作为可介绍业主    企业名称
	companyArr := CrmMysql.SelectBySql(
		fmt.Sprintf("select DISTINCT  b.company_id,b.company_name,a.relate_id,a.relate_name,b.contact_person   from  connection_introduce a  INNER JOIN  connection   b  on  a.position_id=%d  and a.connection_id=b.id  and   a.relate_Id in (%s) and  a.itype =1  and  b.itype=4 and  b.status=1 ", positionId, strings.Join(buyerArr, ",")))
	for _, v := range *companyArr {
		companyId := gconv.String(v["company_id"])
		companyName := gconv.String(v["company_name"])
		relateName := gconv.String(v["relate_name"])
		relateId := gconv.String(v["relate_id"])
		//key := fmt.Sprintf("%s_%s", relateId, companyId)
		returnData = append(returnData, map[string]interface{}{
			"b_id":         companyId,
			"b_name":       companyName,
			"a_name":       relateName,
			"a_id":         relateId,
			"sourceType":   "middleman",
			"relationship": "业主的关系人",
			"personName":   gconv.String(v["contact_person"]),
		})
	}
	return returnData
}

// 企业之间关系查询
func Findfirstparty(buyerArr []string, returnData []map[string]interface{}) []map[string]interface{} {
	buyerSql := fmt.Sprintf(`select DISTINCT 
			a.a_id as a_id,
			a.b_id as b_id,
			a.a_name as a_name,
			a.b_name as b_name,
			a.code as code
		from
			ent_map_code a
		where
			a.a_id in (%s)
			and a.code in('0101', '0201')
			UNION  ALL
			select
			a.b_id as a_id,
			a.a_id as b_id,
			a.b_name as a_name,
			a.a_name as b_name,
			a.code as code
		from
			ent_map_code a
		where
			a.b_id in (%s)
			and a.code in('0101', '0201')`,
		strings.Join(buyerArr, ","),
		strings.Join(buyerArr, ","))
	relationshipArr := BuyerFindConnectionsHandle(buyerSql)
	if relationshipArr != nil && len(relationshipArr) > 0 {
		entIdArr := []string{}
		for _, v := range relationshipArr {
			if v.Bid != "" {
				entIdArr = append(entIdArr, fmt.Sprintf("'%s'", v.Bid))
			}

		}
		personMap := map[string]string{}
		if len(entIdArr) > 0 {
			personSql := fmt.Sprintf(`select  id,name from   ent_contact    where   id in (%s)  ORDER by  name`, strings.Join(entIdArr, ","))
			personArr := PersonFindConnectionsHandle(personSql)
			//联系人处理
			for _, v := range personArr {
				personMap[v.Id] = v.PersonName
			}
		}
		for _, v := range relationshipArr {
			for _, v1 := range buyerArr {
				code := v.Code
				if fmt.Sprintf("'%s'", v.Aid) == v1 {
					//key := fmt.Sprintf("%s_%s", a_id, b_id)
					switch code {
					case "0101": //管辖关系
						returnData = append(returnData, map[string]interface{}{
							"b_id":         v.Bid,
							"b_name":       v.Bname,
							"a_name":       v.Aname,
							"a_id":         v.Aid,
							"sourceType":   "firstparty",
							"relationship": "业主的上级机构",
							"personName":   gconv.String(personMap[v.Bid]),
						})

					case "0201": //投资关系
						returnData = append(returnData, map[string]interface{}{
							"b_id":         v.Bid,
							"b_name":       v.Bname,
							"a_name":       v.Aname,
							"a_id":         v.Aid,
							"sourceType":   "firstparty",
							"relationship": "业主的股东",
							"personName":   gconv.String(personMap[v.Bid]),
						})
					}
				}
				if fmt.Sprintf("'%s'", v.Bid) == v1 {
					//key := fmt.Sprintf("%s_%s", b_id, a_id)
					if code == "0101" {
						//"0101":管辖关系
						returnData = append(returnData, map[string]interface{}{
							"b_id":         v.Aid,
							"b_name":       v.Aname,
							"a_name":       v.Bname,
							"a_id":         v.Bid,
							"sourceType":   "firstparty",
							"relationship": "业主的下级机构",
							"personName":   gconv.String(personMap[v.Aid]),
						})
					}
				}
			}
		}
	}
	return returnData
}

// 采购单位和项目合并
func BuyerProjectMerge(dataMap, projectMap *map[string]map[string]interface{}, sourceType string) ([]BuyerProject, int64, int64, int64) {
	returnData := []BuyerProject{}
	connectionsNumber := int64(0)
	highSuccessNumber := int64(0)
	monitorNumber := int64(0)
	for buyerId, buyerMap := range *dataMap {
		buyerName := gconv.String(buyerMap["buyerName"])
		if _, ok := (*projectMap)[buyerName]; ok {
			projectMap := (*projectMap)[buyerName]
			if isMonitor := gconv.Bool(buyerMap["isMonitor"]); isMonitor {
				monitorNumber++
			}
			count := gconv.Int64(projectMap["count"])
			money := gconv.Int64(projectMap["money"])
			zbtime := gconv.Int64(projectMap["zbtime"])
			if sourceType == "1" {
				if count < 2 {
					continue
				}
				highSuccessNumber++
				returnData = append(returnData, BuyerProject{
					BuyerId:   buyerId,
					BuyerName: buyerName,
					Project: ProjectEntity{
						Number:          count,
						EstimatedAmount: money,
						Connections:     []map[string]interface{}{},
					},
					Area:   gconv.String(projectMap["area"]),
					Zbtime: zbtime,
				})
			} else {
				if count > 2 {
					highSuccessNumber++
				}
				returnData = append(returnData, BuyerProject{
					BuyerId:   buyerId,
					BuyerName: buyerName,
					Project: ProjectEntity{
						Number:          count,
						EstimatedAmount: money,
						Connections:     []map[string]interface{}{},
					},
					Area:   gconv.String(projectMap["area"]),
					Zbtime: zbtime,
				})
			}
		} else {
			returnData = append(returnData, BuyerProject{
				BuyerId:   buyerId,
				BuyerName: buyerName,
				Project: ProjectEntity{
					Number:          0,
					EstimatedAmount: 0,
					Connections:     []map[string]interface{}{},
				},
				Area:   "",
				Zbtime: 0,
			})
		}
		connectionsNumber++
	}
	return returnData, connectionsNumber, highSuccessNumber, monitorNumber
}

// 已监控数据处理
func MonitorStatusInit(positionId int64, dataMap *map[string]map[string]interface{}, sourceType string) {
	monitorMap := map[string]bool{}
	query := map[string]interface{}{
		"userId": gconv.String(positionId),
	}
	clist, ok := Mgo.Find("follow_customer", query, ``, `{"name":1}`, false, -1, -1)
	if ok && clist != nil && len(*clist) > 0 {
		for _, v := range *clist {
			monitorMap[gconv.String(v["name"])] = true
		}

	}
	//采购单位和自己监控的对比
	newMap := &map[string]map[string]interface{}{}
	for k, v := range *dataMap {
		buyerName := gconv.String(v["buyerName"])
		if _, ok1 := monitorMap[gconv.String(buyerName)]; ok1 {
			v["isMonitor"] = true
			(*newMap)[k] = v
		} else {
			if sourceType != "2" && sourceType != "1" {
				v["isMonitor"] = false
				(*newMap)[k] = v
			}
		}
	}
	if newMap != nil {
		dataMap = newMap
	}
}

// 处理状态初始化
func ProcessingStatusInit(positionId int64, dataMap *map[string]map[string]interface{}, processingStatus string) {
	//未处理
	untreatedMap := &map[string]bool{}
	//已忽略
	ignoredMap := &map[string]bool{}
	//已创建
	createdMap := &map[string]bool{}
	processingArr := CrmMysql.Find(entity.CONNECTION_STATUS, map[string]interface{}{
		"type":        1,
		"position id": positionId,
	}, "relate_id,is_handle,is_ignore,is_create", "", -1, -1)
	if len(*processingArr) > 0 {
		for _, v := range *processingArr {
			entId := gconv.String(v["relate_id"])
			handle := gconv.Int64(v["is_handle"])
			ignore := gconv.Int64(v["is_ignore"])
			create := gconv.Int64(v["is_create"])
			if handle == 1 {
				(*untreatedMap)[entId] = true
			}
			if ignore == 1 {
				(*ignoredMap)[entId] = true
			}
			if create == 1 {
				(*createdMap)[entId] = true
			}
		}
	}
	newMap := &map[string]map[string]interface{}{}
	//所有采购单位和处理状态对比
	for buyerId, value := range *dataMap {
		for _, v := range strings.Split(processingStatus, ",") {
			switch v {
			case "1":
				if _, ok := (*untreatedMap)[buyerId]; !ok {
					(*newMap)[buyerId] = value
				}
			case "2":
				if _, ok := (*ignoredMap)[buyerId]; ok {
					(*newMap)[buyerId] = value
				}
			case "3":
				if _, ok := (*createdMap)[buyerId]; ok {
					(*newMap)[buyerId] = value
				}
			}
		}
	}
	if newMap != nil {
		dataMap = newMap
	}
}

// 采购单位查询
func BuyerList(partyA, supplier, heterotophy, intermediary, agency string) *map[string]map[string]interface{} {
	dataMap := &map[string]map[string]interface{}{}
	//甲方
	if partyA != "" {
		for _, v := range strings.Split(partyA, ",") {
			intermediaryArr := strings.Split(v, "_")
			if len(intermediaryArr) == 2 {
				(*dataMap)[intermediaryArr[0]] = map[string]interface{}{
					"buyerName": intermediaryArr[1],
				}
			}
		}
	}
	//供应商 //同甲异业
	if supplier != "" || heterotophy != "" {
		findInSetArr := []string{}
		for _, v := range strings.Split(supplier, ",") {
			findInSetArr = append(findInSetArr, fmt.Sprintf("'%s'", v))
		}
		for _, v := range strings.Split(heterotophy, ",") {
			findInSetArr = append(findInSetArr, fmt.Sprintf("'%s'", v))
		}
		sqlStr := fmt.Sprintf(`SELECT buyer, buyer_id FROM transaction_info where  hasAny(winner_id,[%s])    `, strings.Join(findInSetArr, ","))
		FindHandle(sqlStr, dataMap)
	}
	//中间人
	if intermediary != "" {
		for _, v := range strings.Split(intermediary, ",") {
			intermediaryArr := strings.Split(v, "_")
			if len(intermediaryArr) == 2 {
				(*dataMap)[intermediaryArr[0]] = map[string]interface{}{
					"buyerName": intermediaryArr[1],
				}
			}
		}
	}
	//招标代理
	if agency != "" {
		agencyArr := []string{}
		for _, s := range strings.Split(agency, ",") {
			agencyArr = append(agencyArr, fmt.Sprintf("'%s'", s))
		}
		sqlStr := fmt.Sprintf(`SELECT buyer, buyer_id FROM transaction_info  where agency_id in (%s)   order by  userid`, strings.Join(agencyArr, ","))
		FindHandle(sqlStr, dataMap)
	}
	return dataMap
}

// 项目数量查询
func ProjectHandle(buyerArr []string, positionId int64, entName, area, sourceType, processingStatus string) (*map[string]map[string]interface{}, *map[string]map[string]interface{}) {
	projectMap := &map[string]map[string]interface{}{}
	returnMap := &map[string]map[string]interface{}{}
	sql := ""
	sqlStr := ""
	if entName != "" {
		sql = `{"query":{"bool":{"must":[{"multi_match":{"query":"%s","type":"phrase","fields":["buyer.mbuyer"]}}%s]}},"aggs":{"buyer_count":{"terms":{"field":"buyer","size":500,"order":{"zbtime_count":"desc"}},"aggs":{"area_count":{"terms":{"field":"area"}},"buyer_id":{"terms":{"field":"buyer_id"}},"money_count":{"sum":{"field":"project_money"}},"zbtime_count":{"max":{"field":"zbtime"}}}}},"size":0}`
		sqlStr = fmt.Sprintf(sql, entName, common.If(area != "", fmt.Sprintf(`,{"term":{"area":"%s"}}`, area), ""))
	} else {
		sql = `{"query":{"bool":{"must":[{"terms":{"buyer":[%s]}}%s]}},"aggs":{"buyer_count":{"terms":{"field":"buyer","size":500,"order":{"zbtime_count":"desc"}},"aggs":{"area_count":{"terms":{"field":"area"}},"buyer_id":{"terms":{"field":"buyer_id"}},"money_count":{"sum":{"field":"project_money"}},"zbtime_count":{"max":{"field":"zbtime"}}}}},"size":0}`
		sqlStr = fmt.Sprintf(sql, strings.Join(buyerArr, ","), common.If(area != "", fmt.Sprintf(`,{"term":{"area":"%s"}}`, area), ""))
	}
	startTime := time.Now().Unix()
	data, _, _ := elastic.GetAggs(INDEX_1, INDEX_1, sqlStr)
	endTime := time.Now().Unix()
	fmt.Println("es用时时间：", endTime-startTime)
	if len(data) == 0 {
		return projectMap, returnMap
	}
	for _, object := range data {
		buyerArr := BuyerAggStruct{}
		bs, ok := object.MarshalJSON()
		if ok != nil {
			logx.Error("解析项目数据失败", object)
			continue
		}
		err := json.Unmarshal(bs, &buyerArr)
		logx.Info(err)
		for _, v := range buyerArr.Buckets {
			buyerName := v.Key
			area := ""
			buyerId := ""
			for _, areaEntity := range v.Area_count.Buckets {
				area = Deduplication(area, areaEntity.Key)
			}
			for _, buyerIdEntity := range v.Buyer_id.Buckets {
				if buyerIdEntity.Key != "" {
					buyerId = buyerIdEntity.Key
				}
			}
			(*projectMap)[buyerName] = map[string]interface{}{
				"area":    area,
				"zbtime":  v.Zbtime_count.Value,
				"money":   v.Money_count.Value,
				"count":   v.Doc_count,
				"buyerId": buyerId,
			}
			(*returnMap)[buyerId] = map[string]interface{}{
				"buyerName": buyerName,
			}
		}
	}
	return projectMap, returnMap
}

type BuyerAggStruct struct {
	Buckets []struct {
		Key          string `json:"key,omitempty"`
		Doc_count    int64  `json:"doc_count,omitempty"`
		Zbtime_count struct {
			Value interface{} `json:"value,omitempty"`
		} `json:"zbtime_count,omitempty"`
		Money_count struct {
			Value interface{} `json:"value,omitempty"`
		} `json:"money_count,omitempty"`
		Area_count struct {
			Buckets []struct {
				Key       string `json:"key,omitempty"`
				Doc_count int64  `json:"doc_count,omitempty"`
			}
		} `json:"area_count"`
		Buyer_id struct {
			Buckets []struct {
				Key       string `json:"key,omitempty"`
				Doc_count int64  `json:"doc_count,omitempty"`
			}
		} `json:"buyer_id"`
	}
}

// 采购单位查询sql
func FindHandle(sqlStr string, dataMap *map[string]map[string]interface{}) {
	rows, err := ClickhouseConn.Query(context.Background(), sqlStr)
	if err != nil {
		logx.Error("查询失败", sqlStr, err)
	}
	for rows.Next() {
		data := Recommend{}
		rows.ScanStruct(&data)
		(*dataMap)[data.buyerId] = map[string]interface{}{
			"buyerName": data.buyer,
		}
	}
	return
}

type ConnectionsEntity struct {
	Aid     string `ch:"a_id"`
	Bid     string `ch:"b_id"`
	Aname   string `ch:"a_name"`
	Bname   string `ch:"b_name"`
	Code    string `ch:"code"`
	Cperson string `ch:"c_person"`
}
type PersonEntity struct {
	Id         string `ch:"id"`
	PersonName string `ch:"personName"`
}
type SupplierConnectionsEntity struct {
	Zbtime       int64    `ch:"zbtime"`
	Project_id   string   `ch:"project_id"`
	Project_name string   `ch:"project_name"`
	Buyer_id     string   `ch:"buyer_id"`
	Buyer        string   `ch:"buyer"`
	Agency_id    string   `ch:"agency_id"`
	Agency       string   `ch:"agency"`
	WinnerId     []string `ch:"winner_id"`
	Winner       []string `ch:"winner"`
}
type SupplierConnectionsEntitys struct {
	Zbtime       int64
	Project_id   string
	Project_name string
	Buyer_id     string
	Buyer        string
	Agency_id    string
	Agency       string
	WinnerId     string
	Winner       string
}
type TimeConnectionsEntity struct {
	Zbtime       int64  `ch:"zbtime"`
	Project_id   string `ch:"project_id"`
	Project_name string `ch:"project_name"`
}

// 采购单位人脉信息查询sql
func BuyerFindConnectionsHandle(sqlStr string) []ConnectionsEntity {
	returnData := []ConnectionsEntity{}
	rows, err := ClickhouseConn.Query(context.Background(), sqlStr)
	if err != nil {
		logx.Error("查询失败", sqlStr, err)
	}
	for rows.Next() {
		data := ConnectionsEntity{}
		rows.ScanStruct(&data)
		returnData = append(returnData, data)
	}
	return returnData
}
func PersonFindConnectionsHandle(sqlStr string) []PersonEntity {
	returnData := []PersonEntity{}
	rows, err := ClickhouseConn.Query(context.Background(), sqlStr)
	if err != nil {
		logx.Error("查询失败", sqlStr, err)
	}
	for rows.Next() {
		data := PersonEntity{}
		rows.ScanStruct(&data)
		returnData = append(returnData, data)
	}
	return returnData
}

// 供应商
func SupplierFindConnectionsHandle(sqlStr string) []SupplierConnectionsEntitys {
	returnData := []SupplierConnectionsEntitys{}
	rows, err := ClickhouseConn.Query(context.Background(), sqlStr)
	if err != nil {
		logx.Error("查询失败", sqlStr, err)
	}
	for rows.Next() {
		data := SupplierConnectionsEntity{}
		err = rows.ScanStruct(&data)
		logx.Info(err)
		if len(data.Winner) == 0 {
			returnData = append(returnData, SupplierConnectionsEntitys{
				Zbtime:       data.Zbtime,
				Project_id:   data.Project_id,
				Project_name: data.Project_name,
				Buyer_id:     data.Buyer_id,
				Buyer:        data.Buyer,
				Agency_id:    data.Agency_id,
				Agency:       data.Agency,
				WinnerId:     "",
				Winner:       "",
			})
		} else {

			for k, v := range data.WinnerId {
				fmt.Println(k, len(data.Winner))
				if k+1 > len(data.Winner) {
					continue
				}
				returnData = append(returnData, SupplierConnectionsEntitys{
					Zbtime:       data.Zbtime,
					Project_id:   data.Project_id,
					Project_name: data.Project_name,
					Buyer_id:     data.Buyer_id,
					Buyer:        data.Buyer,
					Agency_id:    data.Agency_id,
					Agency:       data.Agency,
					WinnerId:     gconv.String(v),
					Winner:       gconv.String(data.Winner[k]),
				})
			}
		}

	}
	return returnData
}

// 合作时间查询
func TimeFindConnectionsHandle(sqlStr string) []TimeConnectionsEntity {
	returnData := []TimeConnectionsEntity{}
	rows, err := ClickhouseConn.Query(context.Background(), sqlStr)
	if err != nil {
		logx.Error("查询失败", sqlStr, err)
	}
	for rows.Next() {
		data := TimeConnectionsEntity{}
		rows.ScanStruct(&data)
		returnData = append(returnData, data)
	}
	return returnData
}

// 去重处理
func Deduplication(a, b string) string {
	newArr := []string{}
	if b == "全国" {
		return a
	}
	if a != "" {
		newArr = append(newArr, a)
	}
	if b != "" {
		newArr = append(newArr, b)
	}
	return strings.Join(newArr, ",")
}

// 路径列表
func (t *OwnerService) OwnerRoute() []map[string]interface{} {
	routeList := ConnectionsHandle([]string{
		fmt.Sprintf("'%s'", t.BuyerId),
	}, t.PositionId, false)
	for i, routeMap := range routeList {
		sourceType := gconv.String(routeMap["sourceType"])
		if sourceType == "agency" || sourceType == "supplier" {
			data := routeList[i]
			data["cooperateCount"] = len(gconv.Maps(data["list"]))
			delete(data, "list")
			routeList[i] = data
		}
	}
	return routeList
}

// 合作列表
func (t *OwnerService) OwnerCooperate() []map[string]interface{} {
	returData := []map[string]interface{}{}
	dataArr := []TimeConnectionsEntity{}
	if t.CooperateType == "supplier" {
		//供应商
		supplierSql := fmt.Sprintf(`SELECT
			zbtime,
			project_id,
			project_name
			
		FROM
			transaction_info     
		ARRAY 
		JOIN winner_id  as  winnerId  
		where  buyer_id= '%s' and  winnerId='%s'`, t.BuyerId, t.WinnerId)
		dataArr = TimeFindConnectionsHandle(supplierSql)
	} else if t.CooperateType == "agency" {
		//代理机构
		agentSql := fmt.Sprintf(`select  zbtime,project_id,project_name  from   transaction_info  where  buyer_id ='%s' and  agency_id ='%s' order by zbtime,winner_id `, t.BuyerId, t.WinnerId)
		dataArr = TimeFindConnectionsHandle(agentSql)
	}
	if dataArr != nil && len(dataArr) > 0 {
		for _, m := range dataArr {
			zbtime := m.Zbtime
			returData = append(returData, map[string]interface{}{
				"zbtime":      common.If(zbtime == 0, "", time.Unix(zbtime, 10).Format("2006.01.02")),
				"entName":     t.WinnerName,
				"projectId":   encrypt.EncodeArticleId2ByCheck(m.Project_id),
				"projectName": m.Project_name,
			})
		}
	}
	return returData
}
func (t *OwnerService) CandidateChannel() []*ResultData {
	returnData := []*ResultData{}
	dataMap := &map[string]map[string]interface{}{}
	if t.PartyA != "" || t.Supplier != "" || t.Heterotophy != "" || t.Intermediary != "" || t.Agency != "" {
		dataMap = BuyerList(t.PartyA, t.Supplier, t.Heterotophy, t.Intermediary, t.Agency)
	}
	if len(*dataMap) > 0 && dataMap != nil {
		propertyForm := ""
		m1 := CrmMysql.FindOne("config_tenant", map[string]interface{}{"account_id": t.EntAccountId}, "probusfor", "")
		if m1 != nil && len(*m1) > 0 {
			propertyForm = common.ObjToString((*m1)["probusfor"])
		}
		for buyerId := range *dataMap {
			r1, r2 := GetData(propertyForm, buyerId)
			if r1 != nil && len(r1) > 0 {
				for _, m := range r1 {
					near, zbtime := LastTimeCoop(buyerId, common.ObjToString(m["name"]), "adiffb")
					tmp := ResultData{
						SourceType:  "adiffb",
						EntName:     common.ObjToString(m["name"]),
						ProjectNum:  common.IntAll(m["coop_size"]),
						TotalAmount: common.Float64All(m["coop_amount"]),
						RecentTime:  zbtime,
						NearlyYears: near,
					}
					returnData = append(returnData, &tmp)
				}
			}
			if r2 != nil && len(r2) > 0 {
				for _, m := range r2 {
					near, zbtime := LastTimeCoop(buyerId, common.ObjToString(m["name"]), "agency")
					tmp := ResultData{
						SourceType:  "agency",
						EntName:     common.ObjToString(m["name"]),
						ProjectNum:  common.IntAll(m["coop_size"]),
						TotalAmount: common.Float64All(m["coop_amount"]),
						RecentTime:  zbtime,
						NearlyYears: near,
					}
					returnData = append(returnData, &tmp)
				}
			}

			// 中间人可介绍业主
			var r3 []map[string]interface{}
			r3 = FindMiddleman([]string{buyerId}, t.PositionId, r3)
			if r3 != nil && len(r3) > 0 {
				for _, m := range r3 {
					tmp := ResultData{
						SourceType:   "middleman",
						EntName:      common.ObjToString(m["b_name"]),
						EntPerson:    common.ObjToString(m["personName"]),
						Relationship: "业主的关系人",
					}
					returnData = append(returnData, &tmp)
				}
			}
			// 关联单位
			var r4 []map[string]interface{}
			r4 = Findfirstparty([]string{buyerId}, r4)
			if r4 != nil && len(r4) > 0 {
				for _, m := range r3 {
					tmp := ResultData{
						SourceType:   "sup_sub",
						EntName:      common.ObjToString(m["b_name"]),
						EntPerson:    common.ObjToString(m["personName"]),
						Relationship: common.ObjToString(m["relationship"]),
					}
					returnData = append(returnData, &tmp)
				}
			}
		}
	}
	return returnData
}