networkManage/api/internal/service/owner.go

package service

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"sort"
	"strings"
	"time"

	"app.yhyue.com/moapp/jybase/redis"

	"app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/encrypt"
	elastic "app.yhyue.com/moapp/jybase/es"
	. "bp.jydev.jianyu360.cn/CRM/networkManage/api/common"
	"bp.jydev.jianyu360.cn/CRM/networkManage/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
	Area          string
	PositionId    int64
	PageIndex     int64
	PageSize      int64
	BuyerId       string
	BuyerName     string
	WinnerId      string
	WinnerName    string
	CooperateType string
	EntAccountId  int64
	ProjectType   string
	Type          string
	EntId         int64
	UserId        string
}

type BuyerProject struct {
	BuyerId   string
	BuyerName string
	Project   ProjectEntity
	IsMonitor bool
	Area      string
	Zbtime    int64
	BuyerType string
	CId       string
}
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"`
}

// OwnerlList 执行主要的业务逻辑
func (t *OwnerService) OwnerlList() map[string]interface{} {
	// 先查询采购单位列表
	startTime := time.Now().Unix()
	dataMap := &map[string]map[string]interface{}{}
	projectMap := &map[string]map[string]interface{}{}
	businessStr := FindBusiness(t.EntId, t.UserId)
	// 初始化分页参数
	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
	returnData, connectionsNumber := []BuyerProject{}, int64(0)
	// 如果没有业务字符串，直接返回空数据
	if businessStr == "" {
		return map[string]interface{}{
			"list":              returnData,
			"connectionsNumber": connectionsNumber,
		}
	}
	key := fmt.Sprintf("%+v", t)
	key = fmt.Sprintf("%s%s", key, fmt.Sprintf(" business:%s", businessStr))
	listKey := "ownerlList-" + common.GetMd5String(fmt.Sprintf("%+v", key))
	countKey := "ownerlCount-" + common.GetMd5String(fmt.Sprintf("%+v", key))
	// 检查 Redis 中是否存在列表缓存
	if ok, err := redis.Exists("newother", listKey); ok && err == nil && t.SourceType != "2" {
		returnData = handleRedisCache(listKey)
		connectionsNumber = gconv.Int64(redis.GetInt("newother", countKey))
		// 处理监控状态
	} else {
		log.Println("111", fmt.Sprintf("%+v", key))
		key = "companyList-" + common.GetMd5String(fmt.Sprintf("%+v", key))
		// 检查 Redis 中是否存在公司缓存
		if ok, err := redis.Exists("newother", key); ok && err == nil && t.SourceType != "2" {
			// 处理可介绍业主人脉
			returnData = handleRedisCache(key)
			sortAndPaginateReturnData(&returnData, startIndex, endIndex)
		} else {
			// 没有缓存时的处理逻辑
			if t.PartyA != "" || t.Supplier != "" || t.Heterotophy != "" || t.Intermediary != "" || t.Agency != "" {
				dataMap = BuyerList(t.PartyA, t.Supplier, t.Heterotophy, t.Intermediary, t.Agency, t.PositionId)
				if len(*dataMap) == 0 {
					return map[string]interface{}{
						"connectionsNumber": 0,
						"highSuccessNumber": 0,
						"monitorNumber":     0,
						"list":              []BuyerProject{},
					}
				}
				// 监控状态处理
				MonitorStatusInit(t.PositionId, dataMap, t.SourceType)
				// 项目数量查询
				buyerArr := getBuyerArr(dataMap)
				// 项目数量处理
				projectMap, dataMap = ProjectHandle(buyerArr, t.EntAccountId, t.SearchEntName, t.Area, businessStr, dataMap)
			} else {
				return map[string]interface{}{}
			}
			endTime := time.Now().Unix()
			fmt.Println("用时时间：", endTime-startTime)
			if len(*dataMap) == 0 {
				return map[string]interface{}{}
			}
			// 采购单位和项目合并
			a1 := time.Now().Unix()
			returnData, connectionsNumber = BuyerProjectMerge(dataMap, projectMap, t.SourceType)
			a2 := time.Now().Unix()
			fmt.Println("组合数据", a2-a1)
			if len(returnData) > 0 {
				redis.Put("newother", key, returnData, C.CacheTimeOut)
				sort.Slice(returnData, func(i, j int) bool {
					aa := fmt.Sprintf("%d%s", (returnData)[i].Zbtime, (returnData)[i].BuyerId)
					bb := fmt.Sprintf("%d%s", (returnData)[j].Zbtime, (returnData)[j].BuyerId)
					return aa > bb
				})
				// 数组分页处理
				sortAndPaginateReturnData(&returnData, startIndex, endIndex)
			}

		}
	}
	if ok, err := redis.Exists("newother", listKey); !ok || err != nil || t.SourceType == "2" {
		buyerIdArr := getBuyerIdArr(returnData)
		// 可介绍业主人脉处理
		a3 := time.Now().Unix()
		routeList := ConnectionsHandle(buyerIdArr, t.PositionId, false)
		a4 := time.Now().Unix()
		fmt.Println("组合数1111据", a4-a3)
		updateReturnDataWithRoutes(returnData, routeList)
	}
	if len(returnData) > 0 {
		//监控状态处理
		monitorMap := NetworkCom.EntMonitor(gconv.String(t.PositionId))
		for k, value := range returnData {
			if _, ok := monitorMap[value.BuyerName]; ok {
				returnData[k].IsMonitor = true
			} else {
				returnData[k].IsMonitor = false
			}
		}
		redis.Put("newother", listKey, returnData, C.CacheTimeOut)
		redis.Put("newother", countKey, connectionsNumber, C.CacheTimeOut)

	}
	// 返回数据组装
	return map[string]interface{}{
		"list":              returnData,
		"connectionsNumber": connectionsNumber,
	}
}

// handleRedisCache 处理从 Redis 中获取缓存数据的逻辑
func handleRedisCache(key string) []BuyerProject {
	returnData := []BuyerProject{}
	if bytes, err := redis.GetBytes("newother", key); err == nil && bytes != nil {
		err = json.Unmarshal(*bytes, &returnData)
		if err != nil {
			// 处理解组错误
			fmt.Println("Error unmarshaling from Redis:", err)
		}
	}
	return returnData
}

// getBuyerArr 从数据映射中获取买家数组
func getBuyerArr(dataMap *map[string]map[string]interface{}) []string {
	buyerArr := []string{}
	for _, value := range *dataMap {
		buyerArr = append(buyerArr, fmt.Sprintf(`"%s"`, gconv.String(value["buyerName"])))
	}
	return buyerArr
}

// sortAndPaginateReturnData 对返回数据进行分页处理
func sortAndPaginateReturnData(returnData *[]BuyerProject, startIndex, endIndex int64) {

	if startIndex < int64(len(*returnData)) {
		if endIndex > int64(len(*returnData)) {
			endIndex = int64(len(*returnData))
		}
		*returnData = (*returnData)[startIndex:endIndex]
	}
}

// getBuyerIdArr 从返回数据中获取企业ID 数组
func getBuyerIdArr(returnData []BuyerProject) []string {
	buyerIdArr := []string{}
	for _, value := range returnData {
		if value.BuyerId != "" {
			buyerIdArr = append(buyerIdArr, fmt.Sprintf("'%s'", value.BuyerId))
		}
	}
	return buyerIdArr
}

// updateReturnDataWithRoutes 将路线信息更新到返回数据中
func updateReturnDataWithRoutes(returnData []BuyerProject, routeList []map[string]interface{}) {
	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)
			}
		}
	}
}

// 可介绍业主人脉列表
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 = append(returnData, Findwinner(buyerArr)...)
	a6 := time.Now().Unix()
	logx.Info("供应商", a6-a5)
	return returnData
}

// 供应商处理
func Findwinner(buyerArr []string) []map[string]interface{} {
	returnData := []map[string]interface{}{}
	if len(buyerArr) == 0 {
		return returnData
	}
	//供应商  采购单位 供应商     招标代理机构  采购单位  招标代理机构  需要计算合作次数
	winnerSql := fmt.Sprintf(`select  * from  (select
			zbtime,
			project_id,
			project_name,
			buyer_id,
			buyer,
			entId,
			'supplier' as entType
from
			transaction_info_all ARRAY
JOIN winner_id as entId
where
		buyer_id in (%s)
UNION ALL
		select
			zbtime,
			project_id,
			project_name,
			buyer_id,
			buyer,
			agency_id as entId,
			'agent' as  entType
from
			transaction_info_all
where
		buyer_id in (%s) and  agency_id!='') order by  zbtime DESC,project_id DESC   `, strings.Join(buyerArr, ","), strings.Join(buyerArr, ","))
	winnerArr := SupplierFindConnectionsHandle(winnerSql)
	if winnerArr != nil && len(winnerArr) > 0 {
		//企业联系人处理
		entIdArr := []string{}
		for _, v := range winnerArr {
			if v.EntId != "" {
				entIdArr = append(entIdArr, fmt.Sprintf("'%s'", v.EntId))
			}
		}
		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 {
			if m.EntId == "" {
				continue
			}
			projectId := encrypt.EncodeArticleId2ByCheck(m.Project_id)
			projectName := m.Project_name
			zbtime := m.Zbtime
			key := fmt.Sprintf("%s_%s", m.Buyer_id, m.EntId)
			if m.EntType == "supplier" {
				buyerId := m.Buyer_id
				winner := entNameMap[m.EntId]
				buyer := m.Buyer
				if _, ok := winnerMap[key]; ok {
					data := winnerMap[key]
					data["count"] = gconv.Int64(data["count"]) + 1
					dataList := gconv.Maps(data["list"])
					dataList = append(dataList, map[string]interface{}{
						"zbtime":      zbtime,
						"projectId":   projectId,
						"projectName": projectName,
					})
					data["list"] = dataList
					data["zbtime"] = zbtime
					winnerMap[key] = data
				} else {
					winnerMap[key] = map[string]interface{}{
						"b_id":       m.EntId,
						"b_name":     entNameMap[m.EntId],
						"a_name":     buyer,
						"a_id":       buyerId,
						"sourceType": "supplier",
						"zbtime":     zbtime,
						"personName": personMap[m.EntId],
						"count":      1,
						"list": []map[string]interface{}{
							{
								"zbtime":      zbtime,
								"entName":     winner,
								"projectId":   projectId,
								"projectName": projectName,
							},
						},
					}
				}
			} else {
				agencyId := m.EntId
				key = fmt.Sprintf("%s_%s", m.Buyer_id, agencyId)
				if _, ok := agencyIdMap[key]; ok {
					data := agencyMap[key]
					data["count"] = gconv.Int64(data["count"]) + 1
					dataList := gconv.Maps(data["list"])
					dataList = append(dataList, map[string]interface{}{
						"zbtime":      zbtime,
						"projectId":   projectId,
						"projectName": projectName,
					})
					data["list"] = dataList
					data["zbtime"] = zbtime
					agencyMap[key] = data
				} else {
					agencyIdMap[key] = true
					agencyMap[key] = map[string]interface{}{
						"b_id":       m.EntId,
						"b_name":     entNameMap[m.EntId],
						"a_name":     m.Buyer,
						"a_id":       m.Buyer_id,
						"sourceType": "agency",
						"count":      1,
						"zbtime":     zbtime,
						"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"]),
				"personName":   gconv.String(m["personName"]),
				"list":         m["list"],
				"zbtime":       m["zbtime"],
			})
		}
		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"]),
				"personName":   gconv.String(m["personName"]),
				"count":        gconv.Int64(m["count"]),
				"list":         m["list"],
				"zbtime":       m["zbtime"],
			})
		}
	}
	sort.Slice(returnData, func(i, j int) bool {
		aa := fmt.Sprintf("%s%s", gconv.String(returnData[i]["zbtime"]),
			gconv.String(returnData[i]["b_id"]))
		bb := fmt.Sprintf("%s%s", gconv.String(returnData[j]["zbtime"]),
			gconv.String(returnData[j]["b_id"]))
		return aa > bb
	})
	return returnData
}

// 中间人查询
func FindMiddleman(buyerArr []string, positionId int64, returnData []map[string]interface{}) []map[string]interface{} {
	if len(buyerArr) == 0 {
		return returnData
	}
	//中间人  作为可介绍业主    企业名称
	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"])
		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{} {
	if len(buyerArr) == 0 {
		return returnData
	}
	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,
			111 as   status,
			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,
			222 as   status,
			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 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
			}
		}
		for _, v := range relationshipArr {
			code := v.Code
			status := v.Status
			if gconv.String(status) == "111" {
				//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 gconv.String(status) == "222" {
				//key := fmt.Sprintf("%s_%s", b_id, a_id)
				if code == "0101" {
					//"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]),
					})
				}
				if code == "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]),
					})
				}

			}
		}
	}
	return returnData
}

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

		}
		connectionsNumber++
	}
	return returnData, connectionsNumber
}

// 已监控数据处理
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" {
				v["isMonitor"] = false
				(*newMap)[k] = v
			}
		}
	}
	if sourceType == "2" {
		*dataMap = *newMap
		return
	}
	if newMap != nil {
		*dataMap = *newMap
	}
}
func FindStatus(positionId int64) (map[string]bool, map[string]bool, map[string]bool) {
	//未处理
	untreatedMap := map[string]bool{}
	//已忽略
	ignoredMap := map[string]bool{}
	//已创建
	createdMap := map[string]bool{}
	processingArr := CrmMysql.Find(entity.CONNECTION_STATUS, map[string]interface{}{
		"itype":       1,
		"position_id": positionId,
	}, "relate_id,is_handle,is_ignore,is_create", "", -1, -1)
	if processingArr != nil && 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
			}
		}
	}
	return untreatedMap, ignoredMap, createdMap
}

// 采购单位查询
func BuyerList(partyA, supplier, heterotophy, intermediary, agency string, positionId int64) *map[string]map[string]interface{} {
	dataMap := &map[string]map[string]interface{}{}
	//甲方
	if partyA != "" {
		intermediaryArr := []string{}
		for _, v := range strings.Split(partyA, ",") {
			if v != "" {
				intermediaryArr = append(intermediaryArr, fmt.Sprintf("'%s'", v))
			}
		}
		if len(partyA) > 0 {
			partyASql := fmt.Sprintf(`select  id as buyer_id,company_name as buyer  from  ent_info   where  id in (%s)`, strings.Join(intermediaryArr, ","))
			FindHandle(partyASql, dataMap, "firstparty")
		}
	}
	//供应商 //同甲异业
	findInSetArr := []string{}
	if supplier != "" {
		for _, v := range strings.Split(supplier, ",") {
			if v != "" {
				findInSetArr = append(findInSetArr, fmt.Sprintf("'%s'", v))
			}
		}
	}
	if len(findInSetArr) > 0 {
		sqlStr := fmt.Sprintf(`SELECT buyer_id,buyer FROM transaction_info_all where  hasAny(winner_id,[%s])    `, strings.Join(findInSetArr, ","))
		FindHandle(sqlStr, dataMap, "supplier")
	}
	//同甲异业
	findheterotophyArr := []string{}
	if heterotophy != "" {
		for _, v := range strings.Split(heterotophy, ",") {
			if v != "" {
				findheterotophyArr = append(findheterotophyArr, fmt.Sprintf("'%s'", v))
			}
		}
	}
	if len(findheterotophyArr) > 0 {
		sqlStr := fmt.Sprintf(`SELECT buyer_id,buyer FROM transaction_info_all where  hasAny(winner_id,[%s])    `, strings.Join(findheterotophyArr, ","))
		FindHandle(sqlStr, dataMap, "adiffb")
	}
	//中间人
	if intermediary != "" {
		wh, args := common.WhArgs(strings.Split(intermediary, ","))
		args = append(args, positionId)
		intermediaryArr := CrmMysql.SelectBySql(`select a.id,b.relate_id as relate_id,b.relate_name as relate_name from crm.connection a inner join crm.connection_introduce b on ( a.id in (`+wh+`) and  a.position_id=?  and a.id=b.connection_id and b.itype=1)`, args...)
		if intermediaryArr != nil && len(*intermediaryArr) > 0 {
			for _, m := range *intermediaryArr {
				buyerId := gconv.String(m["relate_id"])
				buyerName := gconv.String(m["relate_name"])
				(*dataMap)[buyerId] = map[string]interface{}{
					"buyerName": buyerName,
					"buyerType": "middleman",
					"cId":       gconv.String(m["id"]),
				}
			}
		}
	}
	//招标代理
	if agency != "" {
		agencyArr := []string{}
		for _, s := range strings.Split(agency, ",") {
			agencyArr = append(agencyArr, fmt.Sprintf("'%s'", s))
		}
		sqlStr := fmt.Sprintf(`SELECT  buyer_id,buyer FROM transaction_info_all  where agency_id in (%s) `, strings.Join(agencyArr, ","))
		FindHandle(sqlStr, dataMap, "agency")
	}
	return dataMap
}

// 项目数量查
func ProjectHandle(buyerArr []string, entAccountId int64, entName, area, businessStr string, dataMap *map[string]map[string]interface{}) (*map[string]map[string]interface{}, *map[string]map[string]interface{}) {
	projectMap := &map[string]map[string]interface{}{}
	returnMap := &map[string]map[string]interface{}{}
	sql := ""
	sqlStr := ""
	propertyFormStr := `"should":[`
	for k, v := range strings.Split(businessStr, ",") {
		if k > 0 {
			propertyFormStr += `,`
		}
		propertyFormStr += `{"term": {"topscopeclass": "` + v + `"}}`
	}
	propertyFormStr += `],"minimum_should_match": 1`
	sql = `{"query":{"bool":{"must_not":[{"term":{"project_bidstatus":1}}],%s,"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, propertyFormStr, 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, dataMap
	}
	for _, object := range data {
		buyerArr := BuyerAggStruct{}
		bs, ok := object.MarshalJSON()
		if ok != nil {
			logx.Error("解析项目数据失败", object)
			continue
		}

		err := json.Unmarshal(bs, &buyerArr)
		if err != nil {
			logx.Error(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":   common.RetainDecimal(common.Float64All(v.Money_count.Value)/10000, 2),
				"count":   v.Doc_count,
				"buyerId": buyerId,
			}
			(*returnMap)[buyerId] = map[string]interface{}{
				"buyerName": buyerName,
				"buyerType": "firstparty",
			}

		}
	}
	if area != "" {
		if entName == "" {
			for buyerId, v := range *dataMap {
				buyerName := gconv.String(v["buyerName"])
				if _, ok := (*projectMap)[buyerName]; !ok {
					delete(*dataMap, buyerId)
				}
			}
		} else {
			for buyerId, v := range *returnMap {
				buyerName := gconv.String(v["buyerName"])
				if _, ok := (*projectMap)[buyerName]; !ok {
					delete(*returnMap, buyerId)
				}
			}
		}

	}
	return projectMap, dataMap
}

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{}, buyerType string) {
	rows, err := ClickhouseConn.Query(context.Background(), sqlStr)
	if err != nil {
		logx.Error("查询失败", sqlStr, err)
	}
	for rows.Next() {
		data := Recommend{}
		rows.ScanStruct(&data)
		if data.BuyerId != "" {
			(*dataMap)[data.BuyerId] = map[string]interface{}{
				"buyerName": data.Buyer,
				"buyerType": buyerType,
			}
		}
	}
	return
}

type ConnectionsEntity struct {
	Aid     string `ch:"a_id"`
	Bid     string `ch:"b_id"`
	Aname   string `ch:"a_name"`
	Bname   string `ch:"b_name"`
	Status  uint8  `ch:"status"`
	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"`
	EntId        string `ch:"entId"`
	EntType      string `ch:"entType"`
}
type SupplierConnectionsEntitys struct {
	Zbtime       int64
	Project_id   string
	Project_name string
	Buyer_id     string
	Buyer        string
	EntId        string
	EntType      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{}
		err := rows.ScanStruct(&data)
		logx.Info(err)
		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)
		if err != nil {
			logx.Error(err)
		}
		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,
			EntId:        data.EntId,
			EntType:      data.EntType,
		})
	}
	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{} {
	if t.BuyerId == "" {
		return []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_all     
		ARRAY 
		JOIN winner_id  as  winnerId  
		where  buyer_id= '%s' and  winnerId='%s' order by  zbtime DESC,project_id DESC `, t.BuyerId, t.WinnerId)
		dataArr = TimeFindConnectionsHandle(supplierSql)
	} else if t.CooperateType == "agency" {
		//代理机构
		agentSql := fmt.Sprintf(`select  zbtime,project_id,project_name  from   transaction_info_all  where  buyer_id ='%s' and  agency_id ='%s' order by  zbtime DESC,project_id DESC   `, 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 FindBusiness(endId int64, userId string) string {
	businessStr := ""
	if endId != 0 {
		//企业
		entInfo := JianyuMysql.FindOne("entniche_info", map[string]interface{}{
			"id": endId,
		}, "", "")
		if (*entInfo)["identity_info"] != nil {
			entMap := gconv.Map((*entInfo)["identity_info"])
			businessStr = gconv.String(entMap["business"])
		}
	} else {
		//个人
		user, ok := Mgo.FindById("user", userId, "")
		if ok && user != nil && len(*user) > 0 {
			if _, ok1 := (*user)["identity_info"]; !ok1 {
				return ""
			}
			identityInfo := gconv.Map((*user)["identity_info"])
			if _, ok1 := identityInfo["is_init"]; !ok1 {
				return ""
			}
			if !gconv.Bool(identityInfo["is_init"]) {
				//设置过
				businessStr = gconv.String(identityInfo["ent_businessType"])
			}
		}
	}
	return businessStr
}