jyMicroservices/jyBXCore/rpc/service/participateStatistics.go

package service

import (
	"app.yhyue.com/moapp/jybase/common"
	"app.yhyue.com/moapp/jybase/encrypt"
	"app.yhyue.com/moapp/jybase/redis"
	"encoding/json"
	"fmt"
	"jyBXCore/rpc/bxcore"
	IC "jyBXCore/rpc/init"
	"jyBXCore/rpc/model/es"
	"log"
	"strconv"
	"strings"
	"time"
)

const (
	//角色
	Role_admin_system     = 1 //系统管理员
	Role_admin_department = 2 //部门管理员
)

type ParticipateStatistics struct {
	PositionId int64
	EntId      int64
	DeptId     int64
	EntUserId  int64
}

func (in *ParticipateStatistics) PushStatistics(entUserIdArr []string, startTime, endTime int64, source []int64) (result []*bxcore.PushStatisticsData) {
	//判断是企业、部门还是个人
	isAdmin, personArrStr, users := in.PersonHandle(entUserIdArr)
	//时间处理
	query := QueryHandle(isAdmin, startTime, endTime, personArrStr, source, 0)
	//推送数据查询
	dataList := IC.BaseMysql.SelectBySql(fmt.Sprintf("select  * from  participate_push_statistics where %s order  by ymd", strings.Join(query, " and ")))
	if users != nil && len(*users) > 0 {
		result = PushHandle(dataList, users, isAdmin)
	}
	return
}

func (in *ParticipateStatistics) ProjectStatistics(entUserIdArr []string, startTime, endTime, bidWay int64) (result []*bxcore.ProjectStatisticsData) {
	//判断是企业、部门还是个人
	isAdmin, personArrStr, users := in.PersonHandle(entUserIdArr)
	query := QueryHandle(isAdmin, startTime, endTime, personArrStr, []int64{}, bidWay)
	//订阅推送数处理
	//推送数据查询
	// 调整为时间倒序  处理投标阶段的时候  只取最新的一条的数据
	dataList := IC.BaseMysql.SelectBySql(fmt.Sprintf("select  * from  participate_project_statistics where %s order  by ymd desc ", strings.Join(query, "and ")))
	if users != nil && len(*users) > 0 {
		result = ProjectHandle(dataList, users, isAdmin)
	}
	return
}

var (
	SelectItemMap = map[int]string{
		1: "个人订阅",
		2: "企业自动分发",
		3: "企业手动分发",
	}
	SourceMap = map[string]string{
		"1": "个人订阅",
		"2": "企业自动分发",
		"3": "企业手动分发",
	}
)

// GetSourceItem 获取标讯项目来源筛选项
func (in *ParticipateStatistics) GetSourceItem(entId, positionId int) (result []*bxcore.SourceItem) {
	redisKey := "sourceItem%s_%s"
	query := "select distinct `source` from participate_push_statistics where "
	// 个人用户
	if entId == 0 {
		// 查职位id
		query += fmt.Sprintf(" position_id =%d", positionId)
		redisKey = fmt.Sprintf(redisKey, "personal", positionId)
	} else {
		// 企业用户 用企业id查
		query += fmt.Sprintf(" end =%d", entId)
		redisKey = fmt.Sprintf(redisKey, "ent", entId)
	}
	if data, err := redis.GetBytes("other", redisKey); err == nil && data != nil {
		err := json.Unmarshal(*data, &result)
		if err == nil {
			return result
		} else {
			log.Println("序列化失败", redisKey, err)
		}
	}
	//
	rs := IC.BaseMysql.SelectBySql(query)
	if rs == nil || len(*rs) == 0 {
		return
	}
	for i := 0; i < len(*rs); i++ {
		value := common.ObjToString((*rs)[i]["source"])
		if value == "" {
			continue
		}
		splitSource := strings.Split(value, ",")
		for j := 0; j < len(splitSource); j++ {
			sourceValue, err := strconv.Atoi(splitSource[j])
			if err != nil {
				log.Println("类型转换错误：", err, splitSource[j])
				continue
			}
			if name, ok := SelectItemMap[sourceValue]; ok {
				result = append(result, &bxcore.SourceItem{
					Name:  name,
					Value: int64(sourceValue),
				})
			}
		}
	}
	if len(result) > 0 {
		//  存缓存
		rsByte, _ := json.Marshal(result)
		redis.PutBytes("other", redisKey, &rsByte, 60*60*2)
	}
	return
}

func (in *ParticipateStatistics) PersonHandle(entUserIdArr []string) (isAdmin bool, idStr string, users *[]map[string]interface{}) {
	userEnt := EntInfo(common.IntAll(in.EntId), common.IntAll(in.EntUserId))
	if len(entUserIdArr) > 0 {
		//查询所选人的部门以及人员信息
		users = GetUser(entUserIdArr)
		//返回所选人的信息
		isAdmin = true
		idStr = strings.Join(entUserIdArr, ",")
	} else {
		if userEnt.Role_admin_department || userEnt.Role_admin_system { //
			// 部门管理员 获取所有部门和子部门员工
			users = GetDisUsers(common.IntAll(in.EntId), userEnt.Dept.Id)
			var staffs []string
			if users != nil && len(*users) > 0 {
				for _, v := range *users {
					staffs = append(staffs, common.InterfaceToStr(v["id"]))
				}
			}
			isAdmin = true
			idStr = strings.Join(staffs, ",")
		} else {
			if userEnt.Dept.Id != 0 {
				entUserIdArr = append(entUserIdArr, common.InterfaceToStr(in.EntUserId))
				users = GetUser(entUserIdArr)
				//返回所选人的信息
				isAdmin = true
				idStr = strings.Join(entUserIdArr, ",")
			} else {
				isAdmin = false
				idStr = common.InterfaceToStr(in.PositionId)
				users = &[]map[string]interface{}{
					map[string]interface{}{
						"id":   in.PositionId,
						"name": "个人",
					},
				}
			}

		}
	}
	return
}

type PushData struct {
	PersonName      string
	entUserId       string
	DepartmentName  string
	PushNumb        map[string]interface{}
	ParticipateNumb map[string]interface{}
	BidNumb         map[string]interface{}
	WinNumb         map[string]interface{}
	BrowseNumb      map[string]interface{}
}
type ProjectData struct {
	PersonName             string
	DepartmentName         string
	entUserId              string
	BidNumb                map[string]interface{} //投标数量
	DirectBidNumb          map[string]interface{} //直接投标数
	ChannelBidNumb         map[string]interface{} //渠道投标数
	WinNumb                map[string]interface{}
	DirectWinNumb          map[string]interface{} //直接中标数
	ChannelWinNumb         map[string]interface{} //渠道中标数
	NotBidNumber           map[string]interface{} //未中标数量
	EndNumb                map[string]interface{} //终止数量
	participateProjectNumb map[string]interface{} // 参标数量
	Stage                  map[string]map[string]interface{}
}

func PushHandle(data *[]map[string]interface{}, users *[]map[string]interface{}, isAdmin bool) []*bxcore.PushStatisticsData {
	result := &map[int64]*PushData{}
	for k, v := range *users {
		(*result)[common.Int64All(v["id"])] = &PushData{
			PersonName:     fmt.Sprintf("%s_%d", common.InterfaceToStr(v["name"]), k),
			DepartmentName: common.InterfaceToStr(v["dept_name"]),
			entUserId:      common.InterfaceToStr(v["id"]),
		}
	}
	if data != nil && len(*data) > 0 {
		for _, v := range *data {
			userId := int64(0)
			if isAdmin {
				userId = common.Int64All(v["ent_user_id"])
			} else {
				userId = common.Int64All(v["position_id"])
			}
			if (*result)[userId] != nil {
				//浏览总数处理处理
				project_id := common.InterfaceToStr(common.InterfaceToStr(v["project_id"]))
				if common.Int64All(v["isvisit"]) > 0 {
					(*result)[userId].BrowseNumb = DataHanle((*result)[userId].BrowseNumb, project_id)
				}
				//推送总数处理
				(*result)[userId].PushNumb = DataHanle((*result)[userId].PushNumb, project_id)
				//参标总数处理
				if common.Int64All(v["isparticipate"]) > 0 {
					(*result)[userId].ParticipateNumb = DataHanle((*result)[userId].ParticipateNumb, project_id)
				}
				//投标总数处理
				if common.Int64All(v["isbid"]) > 0 {
					(*result)[userId].BidNumb = DataHanle((*result)[userId].BidNumb, project_id)
				}
				//中标总数处理
				if common.Int64All(v["win_status"]) != 0 {
					win_status := common.Int64All(v["win_status"])
					if win_status == 1 {
						(*result)[userId].WinNumb = DataHanle((*result)[userId].WinNumb, project_id)
					} else {
						delete((*result)[userId].WinNumb, project_id)
					}
				}
			}
		}
	}
	pushStatisticsList := make([]*bxcore.PushStatisticsData, len(*result))
	for _, v := range *result {
		personName := strings.Split(v.PersonName, "_")[0]
		k := common.Int64All(strings.Split(v.PersonName, "_")[1])
		pushStatisticsList[k] = &bxcore.PushStatisticsData{
			PersonName:      personName,
			DepartmentName:  v.DepartmentName,
			EntUserId:       encrypt.SE.Encode2Hex(v.entUserId),
			PushNumb:        common.Int64All(len(v.PushNumb)),
			ParticipateNumb: common.Int64All(len(v.ParticipateNumb)),
			BidNumb:         common.Int64All(len(v.BidNumb)),
			WinNumb:         common.Int64All(len(v.WinNumb)),
			BrowseNumb:      common.Int64All(len(v.BrowseNumb)),
		}
	}
	return pushStatisticsList
}
func ProjectHandle(data *[]map[string]interface{}, users *[]map[string]interface{}, isAdmin bool) []*bxcore.ProjectStatisticsData {
	result := &map[int64]*ProjectData{}
	for k, v := range *users {
		(*result)[common.Int64All(v["id"])] = &ProjectData{
			PersonName:     fmt.Sprintf("%s_%d", common.InterfaceToStr(v["name"]), k),
			DepartmentName: common.InterfaceToStr(v["dept_name"]),
			entUserId:      common.InterfaceToStr(v["id"]),
		}
	}
	if data != nil && len(*data) > 0 {
		// existProject 已经存在的项目 项目id_用户id
		existProject := map[string]struct{}{}
		for _, v := range *data {
			userId := int64(0)
			if isAdmin {
				userId = common.Int64All(v["ent_user_id"])
			} else {
				userId = common.Int64All(v["position_id"])
			}
			project_id := common.InterfaceToStr(common.InterfaceToStr(v["project_id"]))
			if (*result)[userId] != nil {
				//  参标数量
				(*result)[userId].participateProjectNumb = DataHanle((*result)[userId].participateProjectNumb, project_id)
				//投标数量
				if common.Int64All(v["isbid"]) > 0 {
					(*result)[userId].BidNumb = DataHanle((*result)[userId].BidNumb, project_id)
				}
				//终止参保统计
				if common.Int64All(v["isend"]) != 0 {
					(*result)[userId].EndNumb = DataHanle((*result)[userId].EndNumb, project_id)
				}
				/* p408 调整：
				这里是因为participate_project_statistics 表的数据是多条的
				统计各阶段数据的时候和中标总数的时候只以最新的为准
				但是统计各阶段勾选数量时 重复统计后续删除不好处理 所以这里调整为
				查询的时候根据时间倒序，同一个项目只统计第一条就可以了 每个项目第一条就是当前阶段内最新的
				其他的直接跳过 不用重复统计后续再删除
				*/
				existKey := fmt.Sprintf("%d_%s", userId, project_id)
				if _, ok := existProject[existKey]; !ok {
					existProject[existKey] = struct{}{}
				} else {
					continue
				}
				//直接投标数
				if common.Int64All(v["bid_way"]) > 0 {
					if common.Int64All(v["bid_way"]) == 2 {
						(*result)[userId].ChannelBidNumb = DataHanle((*result)[userId].ChannelBidNumb, project_id)
						delete((*result)[userId].DirectBidNumb, project_id)
					} else {
						(*result)[userId].DirectBidNumb = DataHanle((*result)[userId].DirectBidNumb, project_id)
						delete((*result)[userId].ChannelBidNumb, project_id)
					}
				}
				//中标总数处理
				if common.Int64All(v["win_status"]) != 0 {
					if common.Int64All(v["win_status"]) > 0 {
						//中标数量
						(*result)[userId].WinNumb = DataHanle((*result)[userId].WinNumb, project_id)
						delete((*result)[userId].NotBidNumber, project_id)
					} else {
						//未中标数量
						(*result)[userId].NotBidNumber = DataHanle((*result)[userId].NotBidNumber, project_id)
						delete((*result)[userId].WinNumb, project_id)
					}
				}
				//中标方式处理
				if common.Int64All(v["win_bidway"]) != 0 {
					if common.Int64All(v["win_bidway"]) == 1 {
						//直接投标数量
						(*result)[userId].DirectWinNumb = DataHanle((*result)[userId].DirectWinNumb, project_id)
						delete((*result)[userId].ChannelWinNumb, project_id)
					} else {
						//渠道投标数量
						(*result)[userId].ChannelWinNumb = DataHanle((*result)[userId].ChannelWinNumb, project_id)
						delete((*result)[userId].DirectWinNumb, project_id)
					}
				}
				// 阶段勾选数量统计 只统计第一条
				stage := common.ObjToString(v["bid_stage"])
				if stage != "" {
					stageSplit := strings.Split(stage, ",")
					if (*result)[userId].Stage == nil {
						(*result)[userId].Stage = map[string]map[string]interface{}{}
					}
					for i := 0; i < len(stageSplit); i++ {
						stageK := stageSplit[i]
						(*result)[userId].Stage[stageK] = DataHanle((*result)[userId].Stage[stageSplit[i]], project_id)
					}
				}
			}
		}
	}
	projectStatisticsList := make([]*bxcore.ProjectStatisticsData, len(*result))
	for _, v := range *result {
		personName := strings.Split(v.PersonName, "_")[0]
		k := common.Int64All(strings.Split(v.PersonName, "_")[1])
		tmpStage := map[string]int64{}
		for stageK, stageV := range v.Stage {
			tmpStage[stageK] = int64(len(stageV))
		}
		projectStatisticsList[k] = &bxcore.ProjectStatisticsData{
			PersonName:             personName,
			DepartmentName:         v.DepartmentName,
			EntUserId:              encrypt.SE.Encode2Hex(v.entUserId),
			BidNumb:                common.Int64All(len(v.BidNumb)),
			DirectBidNumb:          common.Int64All(len(v.DirectBidNumb)),
			ChannelBidNumb:         common.Int64All(len(v.ChannelBidNumb)),
			WinNumb:                common.Int64All(len(v.WinNumb)),
			DirectWinNumb:          common.Int64All(len(v.DirectWinNumb)),
			ChannelWinNumb:         common.Int64All(len(v.ChannelWinNumb)),
			NotBidNumber:           common.Int64All(len(v.NotBidNumber)),
			EndNumb:                common.Int64All(len(v.EndNumb)),
			ParticipateProjectNumb: common.Int64All(len(v.participateProjectNumb)),
			Stage:                  tmpStage,
		}
	}
	return projectStatisticsList
}
func EntInfo(entId, entUserId int) *CurrentUser {
	currentUser := &CurrentUser{
		Dept: &Department{},
	}
	user := IC.MainMysql.SelectBySql(`SELECT a.name as user_name from entniche_user a INNER JOIN entniche_user_role b on (a.id=b.user_id) where a.id=? and b.role_id=? limit 1`, entUserId, Role_admin_system)
	if user != nil && len(*user) > 0 {
		currentUser.Role_admin_system = true
		currentUser.User_name, _ = (*user)[0]["user_name"].(string)
		currentUser.User_power = 1
		r := IC.MainMysql.SelectBySql(`SELECT id,name,subdis,nodiff from entniche_department where ent_id=? and pid=0 limit 1`, entId)
		if r != nil && len(*r) == 1 {
			department := JsonUnmarshal((*r)[0], &Department{}).(*Department)
			if department != nil {
				department.Pid = department.Id
				currentUser.Dept = department
			}
		}
	} else {
		//角色、权限
		r := IC.MainMysql.SelectBySql(`SELECT a.name as user_name,a.power as user_power,b.role_id,d.id as dept_id,d.name as dept_name,d.subdis as dept_subdis,d.nodiff as dept_nodiff,e.id as dept_pid from entniche_user a 
			LEFT JOIN entniche_user_role b on (b.user_id=?) 
			INNER JOIN entniche_department_user c on (a.id=? and a.id=c.user_id) 
			INNER JOIN entniche_department d on (c.dept_id=d.id) 
			INNER JOIN entniche_department e on (e.ent_id=? and e.pid=0) 
			order by a.id desc limit 1`, entUserId, entUserId, entId)
		if r != nil && len(*r) == 1 {
			currentUser.User_name, _ = (*r)[0]["user_name"].(string)
			currentUser.User_power = common.IntAll((*r)[0]["user_power"])
			if common.IntAll((*r)[0]["role_id"]) == Role_admin_department {
				currentUser.Role_admin_department = true
			}
			currentUser.Dept.Id = common.IntAll((*r)[0]["dept_id"])
			currentUser.Dept.Pid = common.IntAll((*r)[0]["dept_pid"])
			currentUser.Dept.Name = common.ObjToString((*r)[0]["dept_name"])
			currentUser.Dept.Subdis = common.IntAll((*r)[0]["dept_subdis"])
			currentUser.Dept.Nodiff = common.IntAll((*r)[0]["dept_nodiff"])
		}
	}
	return currentUser
}

// map转结构体
func JsonUnmarshal(m interface{}, s interface{}) interface{} {
	var b []byte
	if v, ok := m.(string); ok {
		b = []byte(v)
	} else if v, ok := m.([]byte); ok {
		b = v
	} else {
		b, _ = json.Marshal(m)
	}
	json.Unmarshal(b, &s)
	return s
}

// 获取部门下可以进行分发的人员(不包含部门名称和部门id)
func GetDisUsers(entId, deptId int) *[]map[string]interface{} {
	r := IC.MainMysql.SelectBySql(`select DISTINCT c.id,c.name,c.phone,c.power,b.dept_id,d.name as dept_name
		from entniche_department_parent a 
		INNER JOIN entniche_department_user b on (b.dept_id=? or (a.pid=? and a.id=b.dept_id)) 
		INNER JOIN entniche_user c on (c.ent_id=? and b.user_id=c.id) 
		INNER JOIN entniche_department d  on  d.id=b.dept_id
		order by b.dept_id , convert(c.name using gbk) COLLATE gbk_chinese_ci asc`, deptId, deptId, entId)
	return r
}
func GetUser(entUserIdArr []string) *[]map[string]interface{} {
	r := IC.MainMysql.SelectBySql("SELECT DISTINCT  a.id,  a.name,  a.phone,  d.id AS dept_id,  d.NAME AS dept_name  " +
		"FROM  entniche_user a " +
		" INNER JOIN entniche_department_user b ON  FIND_IN_SET(a.id,'" + strings.Join(entUserIdArr, ",") +
		"') and  b.user_id = a.id  " +
		" INNER JOIN entniche_department d ON d.id = b.dept_id " +
		" ORDER BY  d.id,  CONVERT ( a.NAME USING gbk ) COLLATE gbk_chinese_ci ASC",
	)
	return r
}

type User struct {
	Id        int
	Name      string //员工姓名
	Mail      string //邮箱
	Phone     string //手机号
	Dept_id   int    //部门id
	Dept_name string //部门名称
	//Role      string //角色
	Power int //权限
}

type CurrentUser struct {
	Role_admin_department bool        //是否是部门管理员
	Role_admin_system     bool        //是否是系统管理员
	Dept                  *Department //部门信息
	BondPhone             string      //手机号
	NickName              string      //昵称
	HeadImageUrl          string      //头像
	PersonalAuth          int         //个人认证
	PersonalAuthReason    string      //个人认证不通过原因
	User_power            int         //是否分配权限
	User_name             string      //用户姓名
}
type Department struct {
	Id         int
	Name       string //部门名
	Pid        int    //上级部门id
	Pname      string //上级部门名称
	Nodiff     int    //全员无差别接收 0：关闭 1：打开
	Subdis     int    //订阅分发 0：关闭 1：打开
	Aid        int    //管理员id
	Aname      string //管理员姓名
	Rname      string //角色名
	User_count int    //该部门下员工的总数
	Dept_count int    //该部门下子部门总数
	Ent_id     int    //公司id
}

func DataHanle(data map[string]interface{}, project_id string) map[string]interface{} {
	if data == nil {
		data = map[string]interface{}{project_id: 1}
	} else {
		data[project_id] = 1
	}
	return data
}
func QueryHandle(isAdmin bool, startTime, endTime int64, personArrStr string, source []int64, bidWay int64) []string {
	//时间处理
	query := []string{}
	if isAdmin {
		//是管理员
		query = append(query, fmt.Sprintf(" ent_user_id in (%s) ", personArrStr))
	} else {
		//不是管理员
		query = append(query, fmt.Sprintf(" position_id = %s ", personArrStr))
	}
	if startTime == 0 && endTime == 0 {
		//没有传时间，默认时间处理
		var start = time.Now().AddDate(0, 0, -30)
		query = append(query, fmt.Sprintf(" ymd >= %s ", start.Format("20060102")))
	}
	if startTime != 0 {
		query = append(query, fmt.Sprintf(" ymd >= %d ", startTime))
	}
	if endTime != 0 {
		query = append(query, fmt.Sprintf(" ymd <= %d ", endTime))
	}
	if len(source) > 0 {
		sourceValue := ""
		for i := 0; i < len(source); i++ {
			sourceValue += fmt.Sprint(source[i]) + ","
		}
		sourceValue = sourceValue[:len(sourceValue)-1]
		query = append(query, fmt.Sprintf(" FIND_IN_SET('%s', a.source)", sourceValue))
	}
	if bidWay != 0 {
		query = append(query, fmt.Sprintf("bid_way = %d", bidWay))
	}
	return query
}
func (in *ParticipateStatistics) ProjectDetails(entUserIdArr []string, detailReq *bxcore.ProjectDetailsReq) (result bxcore.DetailData) {
	//判断是企业、部门还是个人
	isAdmin, personArrStr, _ := in.PersonHandle(entUserIdArr)
	queryType := GetQueryType(detailReq)
	query, countQuery := GetDetailQuery(isAdmin, personArrStr, detailReq, queryType)
	totalCount := IC.BaseMysql.CountBySql(countQuery)
	if totalCount == 0 {
		return
	}
	// 处理数据  这里只是筛选出项目id和阶段信息
	dataList := IC.BaseMysql.SelectBySql(query)
	if dataList == nil || len(*dataList) == 0 {
		return
	}
	// 处理数据 补充项目名称、推送表字段 、格式化数据
	rs := ProjectDetailHandle(*dataList, in.EntId, int(detailReq.PositionId), int(detailReq.PositionType))
	result = bxcore.DetailData{
		List:  rs,
		Total: totalCount,
	}
	// 处理数据
	return
}

//	todo 查询条件待验证
//
// 这个查询只用查出符合筛选条件的项目id 以及该项目对应的stage
// 查询类型  0空搜索 全连接 1查左边 连右表查stage 2只查右表 3内连接
func GetDetailQuery(isAdmin bool, personArrStr string, req *bxcore.ProjectDetailsReq, queryType int) (string, string) {

	// 这是因为数据库中 0是未参标 1是已参标， 接收参数时和其他默认参数保持一致 0-全部 1 是未参标 2 是已参标
	req.IsParticipate -= 1
	if queryType == 0 {
		// 空搜索调整
		query1, query2, query3 := []string{}, []string{}, []string{}
		//没有传时间，默认时间处理
		var start = time.Now().AddDate(0, 0, -30)
		query1 = append(query1, fmt.Sprintf(" a.ymd >= %s ", start.Format("20060102")))
		query2 = append(query2, fmt.Sprintf(" b.update_date >= %s ", start.Format("20060102")))
		if isAdmin {
			//是管理员
			query1 = append(query1, fmt.Sprintf(" a.ent_user_id in (%s) ", personArrStr))
			query2 = append(query2, fmt.Sprintf(" FIND_IN_SET('%s', b.ent_user_ids) ", personArrStr))
			query3 = append(query3, fmt.Sprintf(" FIND_IN_SET('%s', b.ent_user_ids) ", personArrStr))
		} else {
			//不是管理员
			query1 = append(query1, fmt.Sprintf(" a.position_id = %s ", personArrStr))
			query2 = append(query2, fmt.Sprintf(" FIND_IN_SET('%s', b.position_ids) ", personArrStr))
			query3 = append(query3, fmt.Sprintf(" FIND_IN_SET('%s', b.position_ids) ", personArrStr))
		}
		q := `SELECT A.project_id, B.stage
				FROM
				(SELECT DISTINCT(project_id)
				FROM
					(SELECT project_id FROM participate_push_statistics
					WHERE %s UNION 
					SELECT project_id
					FROM participate_stage_statistics
					WHERE %s)
				LIMIT %d , %d) A
                LEFT JOIN
				participate_stage_statistics B ON A.project_id = B.project_id where %s`
		q2 := "select distinct(position_id) from participate_push_statistics where %s union select project_id from participate_stage_statistics where %s "
		q1Str := strings.Join(query1, " and ")
		q2Str := strings.Join(query2, " and ")
		q3Str := strings.Join(query3, " and ")
		return fmt.Sprintf(q, q1Str, q2Str, q3Str), fmt.Sprintf(q2, q1Str, q2Str)
	}
	var q, qCount string
	query := []string{}
	joinStr := ""
	if queryType == 1 {
		if isAdmin {
			//是管理员
			query = append(query, fmt.Sprintf(" a.ent_user_id in (%s) ", personArrStr))
			joinStr = "and a.ent_id = b.ent_id"
		} else {
			query = append(query, fmt.Sprintf(" a.position_id = %s ", personArrStr))
			//不是管理员
			// 个人版
			if req.PositionType == 0 {
				joinStr = "and a.position_id = b.position_ids"
			} else {
				// 企业版  个人 因为是查项目的最新状态信息 所以 用ent_id 和项目id连表
				joinStr = "and a.ent_id = b.ent_id"
			}
		}
		if req.StartTime == 0 && req.EndTime == 0 {
			//没有传时间，默认时间处理
			var start = time.Now().AddDate(0, 0, -30)
			query = append(query, fmt.Sprintf(" a.ymd >= %s ", start.Format("20060102")))
		}
		if req.StartTime != 0 {
			query = append(query, fmt.Sprintf(" a.ymd >= %d ", req.StartTime))
		}
		if req.EndTime != 0 {
			query = append(query, fmt.Sprintf(" a.ymd <= %d ", req.EndTime))
		}
		// 标讯/项目来源
		if len(req.Source) > 0 {
			sourceValue := ""
			for i := 0; i < len(req.Source); i++ {
				if req.Source[i] == 0 {
					sourceValue += "1,2,"
				} else {
					sourceValue += fmt.Sprint(req.Source[i]) + ","
				}
			}
			sourceValue = sourceValue[:len(sourceValue)-1]
			query = append(query, fmt.Sprintf(" FIND_IN_SET('%s', a.source)", sourceValue))
		}
		// 投标类型 投标方式；1：直接投标 2：渠道投标',
		if req.BidWay != 0 {
			query = append(query, fmt.Sprintf("a.bid_way = %d", req.BidWay))
		}
		//参标状态：-1全部，0未参标、1已参标
		if req.IsParticipate != -1 {
			query = append(query, fmt.Sprintf("a.isparticipate = %d", req.IsParticipate))
		}
		q = "select distinct(a.project_id),b.stage,a.id,b.id as  bid  from participate_push_statistics a left join participate_stage_statistics b on(a.project_id=b.project_id %s ) where %s order by a.id desc,b.id desc"
		qCount = "select count(distinct(a.project_id))   from participate_push_statistics a left join participate_stage_statistics b on(a.project_id=b.project_id %s) where %s"
	} else if queryType == 2 {
		if isAdmin {
			//是管理员
			query = append(query, fmt.Sprintf(" FIND_IN_SET('%s', b.ent_user_ids) ", personArrStr))
		} else {
			//不是管理员
			query = append(query, fmt.Sprintf(" FIND_IN_SET('%s', b.position_ids)", personArrStr))
		}
		// 参标状态更新时间
		if req.BidUpdateStartTime != "" {
			query = append(query, fmt.Sprintf("b.update_date > %s", req.BidUpdateStartTime))
		}
		if req.BidUpdateEndTime != "" {
			query = append(query, fmt.Sprintf("b.update_date > %s", req.BidUpdateStartTime))
		}
		if req.BidWay != 0 {
			query = append(query, fmt.Sprintf("b.bid_way = %d", req.BidWay))
		}
		//参标状态：-1全部，0未参标、1已参标
		if req.IsParticipate == 1 {
			query = append(query, fmt.Sprintf("b.isparticipate = %d", req.IsParticipate))
		}
		q = "select distinct(b.project_id),b.stage,a.id,b.id   from  participate_stage_statistics b where %s %s order by b.id desc"
		qCount = "select count(b.project_id)   from  participate_stage_statistics b where %s %s"
	} else {
		if isAdmin {
			//是管理员
			query = append(query, fmt.Sprintf(" a.ent_user_id in (%s) ", personArrStr))
			joinStr = "and a.ent_id = b.ent_id"
		} else {
			query = append(query, fmt.Sprintf(" a.position_id = %s ", personArrStr))
			//不是管理员
			// 个人版
			if req.PositionType == 0 {
				joinStr = "and a.position_id = b.position_ids"
			} else {
				// 企业版  个人 因为是查项目的最新状态信息 所以 用ent_id 和项目id连表
				joinStr = "and a.ent_id = b.ent_id"
			}
		}
		if req.StartTime != 0 {
			query = append(query, fmt.Sprintf(" a.ymd >= %d ", req.StartTime))
		}
		if req.EndTime != 0 {
			query = append(query, fmt.Sprintf(" a.ymd <= %d ", req.EndTime))
		}
		if len(req.Source) > 0 {
			sourceValue := ""
			for i := 0; i < len(req.Source); i++ {
				if req.Source[i] == 0 {
					sourceValue += "1,2," // 选择未分发时  相当于选择个人订阅和企业自动分发
				} else {
					sourceValue += fmt.Sprint(req.Source[i]) + ","
				}
			}
			sourceValue = sourceValue[:len(sourceValue)-1]
			query = append(query, fmt.Sprintf(" FIND_IN_SET('%s', a.source)", sourceValue))
		}
		//参标状态：-1全部，0未参标、1已参标
		if req.IsParticipate != -1 {
			query = append(query, fmt.Sprintf("a.isparticipate = %d", req.IsParticipate))
		}
		// 投标类型 投标方式；1：直接投标 2：渠道投标',
		if req.BidWay != 0 {
			query = append(query, fmt.Sprintf("a.bid_way = %d", req.BidWay))
		}
		// 参标状态更新时间
		if req.BidUpdateStartTime != "" {
			query = append(query, fmt.Sprintf("b.update_date > %s", req.BidUpdateStartTime))
		}
		if req.BidUpdateEndTime != "" {
			query = append(query, fmt.Sprintf("b.update_date > %s", req.BidUpdateStartTime))
		}
		q = "select distinct(a.project_id),b.stage,a.id,b.id   from participate_push_statistics a inner join  participate_stage_statistics b on(b.project_id=a.project_id %s) where %s order by a.id desc,b.id desc"
		qCount = "select count(distinct(a.project_id))   from participate_push_statistics a inner join participate_stage_statistics b on(b.project_id=a.project_id %s) where %s"
	}
	if len(query) > 0 {
		q = fmt.Sprintf(q, joinStr, strings.Join(query, " and "))
		qCount = fmt.Sprintf(qCount, joinStr, strings.Join(query, " and "))
	}
	// 处理分页
	if req.PageNum == 0 && req.PageSize == 0 {
		req.PageNum = 1
		req.PageSize = 50
	}
	q = fmt.Sprintf("%s limit %d,%d", q, (req.PageNum-1)*req.PageSize, req.PageSize)
	return q, qCount
}

type PushInfoStruct struct {
	Source       string
	VisitDate    string
	DisDate      string
	IsDistribute int
}

func ProjectDetailHandle(dataList []map[string]interface{}, entId int64, positionId, positionType int) []*bxcore.ProjectDetailData {
	//dataList 里面包含 项目id、各阶段信息
	// 处理项目名称
	projectIdList := []string{}
	for i := 0; i < len(dataList); i++ {
		projectIdList = append(projectIdList, common.ObjToString(dataList[i]["project_id"]))
	}
	// 项目名称处理成map用于后续使用
	projectNameMap := map[string]string{}
	projectNameRs := es.GetProjectNameByProjectId(projectIdList)
	if projectNameRs != nil && len(*projectNameRs) > 0 {
		for i := 0; i < len(*projectNameRs); i++ {
			projectId_ := common.ObjToString((*projectNameRs)[i]["_id"])
			projectName_ := (*projectNameRs)[i]["projectname"]
			projectNameMap[projectId_] = common.ObjToString(projectName_)
		}
	}
	// 获取推送最新状态
	newPushInfo := getNewPushInfo(projectIdList, int(entId), positionId, positionType)
	newPushInfoMap := map[string]PushInfoStruct{}
	// 处理推送最新状态
	if newPushInfo != nil && len(*newPushInfo) > 0 {
		for i := 0; i < len(*newPushInfo); i++ {
			project_ := common.ObjToString((*newPushInfo)[i]["project_id"])
			info := PushInfoStruct{
				Source:    common.ObjToString((*newPushInfo)[i]["source"]),
				VisitDate: common.ObjToString((*newPushInfo)[i]["visit_date"]),
				DisDate:   common.ObjToString((*newPushInfo)[i]["dis_date"]),
			}
			newPushInfoMap[project_] = info
		}
	}
	results := []*bxcore.ProjectDetailData{}
	// 处理成最后的数据
	for i := 0; i < len(dataList); i++ {
		projectId := common.ObjToString(dataList[i]["project_id"])
		tmp := bxcore.ProjectDetailData{
			ProjectName: projectNameMap[projectId],
		}
		isDistribute_ := ""
		// 处理推送表相关字段
		if pushInfo_, ok := newPushInfoMap[projectId]; ok {
			sourceStr := []string{}
			if tmp.Source != "" {
				isDistribute_ = "未分发"
				sourceSplit := strings.Split(pushInfo_.Source, ",")
				for j := 0; j < len(sourceSplit); j++ {
					if sourceSplit[j] == "3" {
						isDistribute_ = "已分发"
					}

					if sourceName, ok := SourceMap[sourceSplit[j]]; ok {
						sourceStr = append(sourceStr, sourceName)
					}
				}
			}
			tmp.Source = strings.Join(sourceStr, ",") //  处理成中文
			tmp.ViewDate = pushInfo_.VisitDate
			tmp.IsDistribute = isDistribute_
			tmp.DisDate = pushInfo_.DisDate
		} //
		// 处理阶段勾选信息和参标、终止参标信息
		if dataList[i]["stage"] != nil {
			if stage_, err := json.Marshal(dataList[i]["stage"]); err == nil {
				err := json.Unmarshal(stage_, &tmp.Stage)
				if err != nil {
					log.Println("stage 反序列失败", err)
				}
			}
		}
		results = append(results, &tmp)
	}
	return results
}

// 获取项目的最新推送状态信息
func getNewPushInfo(projectIds []string, entId int, positionId int, positionType int) *[]map[string]interface{} {
	s := ""
	if positionType == 0 {
		s = fmt.Sprintf("position_id=%d", positionId)
	} else {
		s = fmt.Sprintf("ent_id=%d", entId)
	}
	sql := `
SELECT 
    A.project_id, A.source, A.visit_date, A.dis_date, A.is_distribute,A.id,A.ymd,B.ymd
FROM  participate_push_statistics A inner join (SELECT 
            project_id,MAX(ymd) as ymd
        FROM
            participate_push_statistics
        WHERE
            %s
            AND project_id IN ( "` + strings.Join(projectIds, "\",\"") + `" )
        GROUP BY project_id) B  on (A.project_id=B.project_id and A.ymd=b.ymd) where A.%s
`
	query := fmt.Sprintf(sql, s, s)
	return IC.BaseMysql.SelectBySql(query)
}

// GetQueryType 查询类型  0空搜索 全连接 1查左边 连右表查stage 2只查右表 3内连接
// IsParticipate 接收参数时 0 全部 1 未参标 2已参标  数据库中 未参标是0
func GetQueryType(in *bxcore.ProjectDetailsReq) int {
	// TODO 调整
	if in.BidUpdateStartTime == "" && in.BidUpdateEndTime == "" && in.StartTime == 0 && in.EndTime == 0 && in.IsParticipate == -1 && in.BidWay == 0 && len(in.Source) == 0 {
		return 0
	}
	if in.IsParticipate == 1 {
		// 未参标只筛选推送表 右表条件无效
		return 1
	}
	if (in.StartTime != 0 || in.EndTime != 0 || len(in.Source) > 0) && (in.BidUpdateStartTime == "" && in.BidUpdateEndTime == "" && in.IsParticipate != 2) {
		return 1
	}
	if (in.StartTime == 0 && in.EndTime == 0 && len(in.Source) == 0) && (in.BidUpdateStartTime != "" || in.BidUpdateEndTime == "" || in.IsParticipate == 2 || in.BidWay != 0) {
		return 2
	}
	return 3
}