data_validation/src/front/group.go

package front

import (
	"encoding/json"
	"fmt"
	"github.com/shopspring/decimal"
	"github.com/tealeg/xlsx"
	"go.mongodb.org/mongo-driver/bson"
	"io"
	"mongodb"
	"os"
	qu "qfw/util"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"
	"util"
)

// GroupTaskListByGroup 用户组权限用户组任务列表
func (f *Front) GroupTaskListByGroup() {
	defer qu.Catch()
	if f.Method() == "POST" {
		user := f.GetSession("user").(map[string]interface{})
		role := qu.ObjToString(user["i_role"])
		start, _ := f.GetInteger("start")
		limit, _ := f.GetInteger("length")
		draw, _ := f.GetInteger("draw")
		status := f.GetString("s_status")
		searchStr := f.GetString("search[value]")
		search := strings.TrimSpace(searchStr)
		groupId := qu.ObjToString(user["s_groupid"])
		query := map[string]interface{}{
			"s_stype": "group", //检索用户组任务
		}
		if role != "0" {
			query["s_groupid"] = groupId
		}
		if status != "-1" { //任务状态
			query["s_status"] = status
		} else {
			query["s_status"] = map[string]interface{}{
				"$in": []string{"未开始", "进行中", "已完成"},
			}
		}
		if search != "" {
			query["$or"] = []interface{}{
				map[string]interface{}{"s_projectname": map[string]interface{}{"$regex": search}},
			}
		}
		qu.Debug("Query：", query)
		list, _ := util.Mgo.Find(util.TASKCOLLNAME, query, map[string]interface{}{"_id": -1}, nil, false, start, limit)
		count := util.Mgo.Count(util.TASKCOLLNAME, query)
		for _, l := range *list {
			if status := qu.ObjToString(l["s_status"]); status == "进行中" { //更新任务进度
				//groupId := qu.ObjToString(l["s_groupid"])
				groupTaskId := mongodb.BsonIdToSId(l["_id"])
				giveNum := qu.IntAll(l["i_givenum"])
				tagNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": groupTaskId, "b_istag": true})
				progressFloat := float64(tagNum) / float64(giveNum)
				value, _ := strconv.ParseFloat(fmt.Sprintf("%.4f", progressFloat), 64)
				decimalValue := decimal.NewFromFloat(value)
				decimalValue = decimalValue.Mul(decimal.NewFromInt(100))
				value, _ = decimalValue.Float64()
				progress := fmt.Sprint(value) + "%"
				l["s_progress"] = progress
				//同步数据库
				util.Mgo.UpdateById(util.TASKCOLLNAME, l["_id"], map[string]interface{}{"$set": map[string]interface{}{"s_progress": progress}})
			}
		}
		f.ServeJson(map[string]interface{}{"draw": draw, "data": *list, "recordsFiltered": count, "recordsTotal": count})
	} else {
		_ = f.Render("project/task_group_list.html")
	}
}

// GroupTaskListByAdmin 系统管理员权限用户组任务列表
func (f *Front) GroupTaskListByAdmin() {
	defer qu.Catch()
	if f.Method() == "POST" {
		start, _ := f.GetInteger("start")
		limit, _ := f.GetInteger("length")
		draw, _ := f.GetInteger("draw")
		status := f.GetString("s_status")
		searchStr := f.GetString("search[value]")
		search := strings.TrimSpace(searchStr)
		starttime, _ := f.GetInt("i_starttime")
		completetime, _ := f.GetInt("i_completetime")
		query := map[string]interface{}{
			"s_stype": "group", //检索用户组任务
		}
		//if starttime > 0 {
		//	query["i_starttime"] = map[string]interface{}{
		//		"$gte": starttime,
		//	}
		//}
		dataQ := make(map[string]interface{})
		if starttime > 0 {
			dataQ["$gte"] = starttime
		}
		if completetime > 0 {
			dataQ["$lte"] = completetime
		}
		if len(dataQ) > 0 {
			query["i_completetime"] = dataQ
		}
		if status != "-1" { //任务状态
			query["s_status"] = status
		} else {
			query["s_status"] = map[string]interface{}{
				"$in": []string{"未开始", "进行中", "已完成"},
			}
		}
		if search != "" {
			query["$or"] = []interface{}{
				map[string]interface{}{"s_projectname": map[string]interface{}{"$regex": search}},
				map[string]interface{}{"s_entname": map[string]interface{}{"$regex": search}},
				map[string]interface{}{"s_rulename": map[string]interface{}{"$regex": search}},
				map[string]interface{}{"s_departname": map[string]interface{}{"$regex": search}},
				map[string]interface{}{"s_groupname": map[string]interface{}{"$regex": search}},
			}
		}
		qu.Debug("Query：", query)
		count := util.Mgo.Count(util.TASKCOLLNAME, query)
		list, _ := util.Mgo.Find(util.TASKCOLLNAME, query, map[string]interface{}{"_id": -1}, nil, false, start, limit)
		for _, l := range *list {
			if status := qu.ObjToString(l["s_status"]); status == "进行中" { //更新任务进度
				//groupId := qu.ObjToString(l["s_groupid"])
				groupTaskId := mongodb.BsonIdToSId(l["_id"])
				giveNum := qu.IntAll(l["i_givenum"])
				tagNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": groupTaskId, "b_istag": true})
				progressFloat := float64(tagNum) / float64(giveNum)
				value, _ := strconv.ParseFloat(fmt.Sprintf("%.4f", progressFloat), 64)
				decimalValue := decimal.NewFromFloat(value)
				decimalValue = decimalValue.Mul(decimal.NewFromInt(100))
				value, _ = decimalValue.Float64()
				progress := fmt.Sprint(value) + "%"
				l["s_progress"] = progress
				//同步数据库
				util.Mgo.UpdateById(util.TASKCOLLNAME, l["_id"], map[string]interface{}{"$set": map[string]interface{}{"s_progress": progress}})
			}
		}

		f.ServeJson(map[string]interface{}{"draw": draw, "data": *list, "recordsFiltered": count, "recordsTotal": count})
	} else {
		_ = f.Render("project/task_list.html")
	}
}

// GroupUserTaskList 用户任务分发列表
func (f *Front) GroupUserTaskList() {
	defer qu.Catch()
	groupId := f.GetString("s_groupid") //用户组id
	pid := f.GetString("pid")
	groupTaskId := f.GetString("grouptaskid") //用户组任务id
	qu.Debug("groupTaskId：", groupTaskId)
	if f.Method() == "POST" {
		start, _ := f.GetInteger("start")
		limit, _ := f.GetInteger("length")
		draw, _ := f.GetInteger("draw")
		status := f.GetString("s_status")
		login := f.GetString("s_login")
		searchStr := f.GetString("search[value]")
		search := strings.TrimSpace(searchStr)
		query := map[string]interface{}{
			"s_stype":    "user",
			"s_parentid": groupTaskId,
		}
		if status != "-1" { //任务状态
			query["s_status"] = status
		}
		if login != "-1" { //用户账号
			query["s_login"] = login
		}
		if search != "" {
			query["$or"] = []interface{}{
				map[string]interface{}{"s_projectname": map[string]interface{}{"$regex": search}},
			}
		}
		qu.Debug("Query：", query)
		count := util.Mgo.Count(util.TASKCOLLNAME, query)
		list, _ := util.Mgo.Find(util.TASKCOLLNAME, query, map[string]interface{}{"_id": -1}, nil, false, start, limit)
		for _, l := range *list {
			if status := qu.ObjToString(l["s_status"]); status == "进行中" { //更新任务进度
				giveNum := qu.IntAll(l["i_givenum"])
				tagNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_usertaskid": mongodb.BsonIdToSId(l["_id"]), "b_istag": true})
				progressFloat := float64(tagNum) / float64(giveNum)
				value, _ := strconv.ParseFloat(fmt.Sprintf("%.4f", progressFloat), 64)
				decimalValue := decimal.NewFromFloat(value)
				decimalValue = decimalValue.Mul(decimal.NewFromInt(100))
				value, _ = decimalValue.Float64()
				progress := fmt.Sprint(value) + "%"
				l["s_progress"] = progress
				//同步数据库
				util.Mgo.UpdateById(util.TASKCOLLNAME, l["_id"], map[string]interface{}{"$set": map[string]interface{}{"s_progress": progress}})
			}
		}
		f.ServeJson(map[string]interface{}{"draw": draw, "data": *list, "recordsFiltered": count, "recordsTotal": count})
	} else {
		//统计数据量
		isGiveNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": groupTaskId, "b_isgiveuser": true})     //已分发量
		isNotGiveNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": groupTaskId, "b_isgiveuser": false}) //待分发量
		isTagNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": groupTaskId, "b_istag": true})           //已标注数量
		isNotTagNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": groupTaskId, "b_istag": false})       //未标注数量
		allNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": groupTaskId})                              //数据总量
		qu.Debug("数据总量：", allNum, "已分发量：", isGiveNum, "待分发量：", isNotGiveNum, "已标注量：", isTagNum, "未标注量：", isNotTagNum)
		f.T["pid"] = pid
		f.T["gid"] = groupId
		f.T["grouptaskid"] = groupTaskId
		f.T["allNum"] = allNum
		f.T["isGiveNum"] = isGiveNum
		f.T["isNotGiveNum"] = isNotGiveNum
		f.T["isTagNum"] = isTagNum
		f.T["isNotTagNum"] = isNotTagNum
		if f.GetString("stype") == "jy" {
			f.T["jy"] = "jy"
		} else {
			f.T["group"] = "group"
		}
		_ = f.Render("project/task_detail.html", &f.T)
	}
}

// GroupTaskDeliver 用户组任务交付
func (f *Front) GroupTaskDeliver() {
	defer qu.Catch()
	user := f.GetSession("user").(map[string]interface{})
	username := qu.ObjToString(user["s_login"]) //当前登录用户
	success := false
	msg := ""
	groupTaskId := f.GetString("taskid") //用户组任务id
	qu.Debug("Group Task ID：", groupTaskId)
	groupTask, _ := util.Mgo.FindById(util.TASKCOLLNAME, groupTaskId, map[string]interface{}{"v_sonids": 1, "s_projectid": 1})
	if groupTask != nil && len(*groupTask) > 0 {
		sonUserIds := (*groupTask)["v_sonids"].([]interface{})
		if len(sonUserIds) > 0 {
			dataCount := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": groupTaskId, "b_istag": false})
			taskCount := util.Mgo.Count(util.TASKCOLLNAME, map[string]interface{}{"s_parentid": groupTaskId, "s_status": map[string]interface{}{"$in": []string{"未开始", "进行中"}}})
			if dataCount == 0 && taskCount == 0 {
				success = util.Mgo.UpdateById(util.TASKCOLLNAME, groupTaskId, map[string]interface{}{
					"$set": map[string]interface{}{
						"i_completetime": time.Now().Unix(),
						"s_updateperson": username,
						"i_updatetime":   time.Now().Unix(),
						"s_status":       "已完成",
						"s_progress":     "100%",
					},
				})
				if !success {
					msg = "更新任务信息失败"
				}
			} else {
				if taskCount != 0 {
					msg += "用户任务未全部完成;"
				}
				if dataCount != 0 {
					msg += "数据未全部标注;"
				}
			}
		} else {
			msg = "任务暂未分配"
		}
	} else {
		msg = "查询任务失败"
	}

	pid := qu.ObjToString((*groupTask)["s_projectid"])
	// 组任务交付 默认保存质检统计结果
	mp := make(map[string]interface{})
	mp["s_username"] = username
	mp["s_taskid"] = groupTaskId
	mp["i_createtime"] = time.Now().Unix()
	checkStat(groupTaskId, pid, mp)
	util.Mgo.Save("f_check_result", mp)

	// 项目下的数据全部完成，项目中打上标记b_iscomplete
	pinfo, _ := util.Mgo.FindById(util.PROJECTCOLLNAME, pid, bson.M{"appid": 1})
	info, _ := util.Mgo.FindOneByField(util.TASKCOLLNAME, map[string]interface{}{"b_istag": false, "appid": qu.ObjToString((*pinfo)["appid"])}, map[string]interface{}{"s_status": 1})
	if len(*info) == 0 {
		util.Mgo.UpdateById(util.PROJECTCOLLNAME, pid, map[string]interface{}{"$set": map[string]interface{}{"b_iscomplete": true}})
	}
	f.ServeJson(map[string]interface{}{"success": success, "msg": msg})
}

func (f *Front) TaskSyncJy() {
	defer qu.Catch()
	pid := f.GetString("pid")
	appid := f.GetString("appid")
	pici, _ := f.GetInt("pici")
	project, _ := util.Mgo.FindById(util.PROJECTCOLLNAME, pid, bson.M{"v_add_data": 1})
	importNum := 0
	for _, v := range (*project)["v_add_data"].([]interface{}) {
		v1 := v.(map[string]interface{})
		if qu.Int64All(v1["pici"]) == pici {
			importNum = qu.IntAll(v1["i_importnum"])
			break
		}
	}
	tagNum := util.Mgo.Count(util.DATACOLLNAME, bson.M{"appid": appid, "pici": pici, "b_istag": true})
	if importNum > 0 && importNum == tagNum {
		c := syncJyData(pici, appid)
		if c > 0 {
			//util.Mgo.UpdateById(util.TASKCOLLNAME, groupTaskId, bson.M{"$set": bson.M{"sendflag": true}})
			f.ServeJson(map[string]interface{}{"success": true, "msg": "数据推送成功", "count": c})
		} else {
			f.ServeJson(map[string]interface{}{"success": false, "msg": "数据推送失败"})
		}
	} else {
		f.ServeJson(map[string]interface{}{"success": false, "msg": "数据未清洗完"})
	}
}

func syncJyData(pici int64, appid string) int {
	sess := util.Mgo.GetMgoConn()
	defer util.Mgo.DestoryMongoConn(sess)

	ch := make(chan bool, 5)
	wg := &sync.WaitGroup{}

	q := bson.M{"pici": pici, "appid": appid}
	query := sess.DB(util.Mgo.DbName).C(util.DATACOLLNAME).Find(q).Select(nil).Iter()
	count := 0
	for tmp := make(map[string]interface{}); query.Next(&tmp); count++ {
		ch <- true
		wg.Add(1)
		go func(tmp map[string]interface{}) {
			defer func() {
				<-ch
				wg.Done()
			}()
			info := tmp["v_baseinfo"].(map[string]interface{})
			info["createtime"] = time.Now().Unix()
			if qu.ObjToString(info["id"]) == "" {
				info["id"] = tmp["id"]
			}
			info["isOptimization"] = 1
			util.MgoJy.Save(util.JYPushColl, info)
			util.Mgo.UpdateById(util.DATACOLLNAME, tmp["_id"], bson.M{"$set": bson.M{"sendflag": true}})

		}(tmp)
		tmp = make(map[string]interface{})
	}
	wg.Wait()
	qu.Debug(fmt.Sprintf("推送数据成功，推送成功： %d条", count))
	return count
}

func checkStat(groupTaskId, pid string, mp map[string]interface{}) {
	sess := util.Mgo.GetMgoConn()
	defer util.Mgo.DestoryMongoConn(sess)

	var allNum int
	markNum, checkNum, checkNumR := 0, 0, 0 // 标注数量，	审核数据量，	审核数据完全正确的数据量
	cmaps := make(map[string]int)           // 标注字段整体准确率
	umaps := make(map[string]interface{})   // 按人员 字段准确率

	task, _ := util.Mgo.FindById(util.TASKCOLLNAME, groupTaskId, map[string]interface{}{"i_givenum": 1})
	allNum = qu.IntAll((*task)["i_givenum"])
	projcet, _ := util.Mgo.FindById(util.PROJECTCOLLNAME, pid, map[string]interface{}{"v_fields": 1})

	query := map[string]interface{}{"s_grouptaskid": groupTaskId}
	result := sess.DB(util.Mgo.DbName).C(util.DATACOLLNAME).Find(query).Iter()

	fields := qu.ObjArrToMapArr((*projcet)["v_fields"].([]interface{}))
	fs := make(map[string]string)
	for _, v := range fields {
		key := qu.ObjToString(v["key"])
		if key == "extend" && v["child"] != nil {
			for _, v1 := range qu.ObjArrToMapArr(v["child"].([]interface{})) {
				key1 := qu.ObjToString(v1["key"])
				fs[key1] = qu.ObjToString(v1["descript"])
			}
		} else {
			fs[key] = qu.ObjToString(v["descript"])
		}
	}
	purchasingTag := false // 标的物统计标识
	var strs []string
	if fs["purchasinglist"] != "" {
		purchasingTag = true
		delete(fs, "purchasinglist")
	}
	for k := range fs {
		strs = append(strs, k)
	}
	pNum, pEffNum := 0, 0               // 标的物数量, 标的物有效数量
	fieldNumMap := make(map[string]int) //字段总标注量，
	tagNumMap := make(map[string]int)   //字段标注数据量（标的物有效）
	rightNumMap := make(map[string]int) //正确数据（标的物有效）
	for tmp := make(map[string]interface{}); result.Next(&tmp); markNum++ {
		user := qu.ObjToString(tmp["s_login"])
		var up map[string]int
		if umaps[user] == nil {
			up = make(map[string]int)
		} else {
			up = umaps[user].(map[string]int)
		}
		up["ck_count"] += 1
		umaps[user] = up
		if tmp["b_check"].(bool) {
			if f, ok := tmp["v_checkinfo"].(map[string]interface{}); ok {
				flag := true // 数据整体准确率
				// 按人员统计字段准备率
				var up map[string]int
				if umaps[user] == nil {
					up = make(map[string]int)
				} else {
					up = umaps[user].(map[string]int)
				}
				for k1 := range cmaps {
					if qu.IntAll(f[k1]) == 1 {
						cmaps[k1] += 1 // 字段整体正确率
						up[k1] += 1
					} else {
						flag = false
					}
				}
				up["re_count"] += 1
				umaps[user] = up
				if flag {
					checkNumR++
					up["re_rg_count"] += 1
				}
			}
		}
		if tmp["b_check"].(bool) && purchasingTag {
			info := tmp["v_baseinfo"].(map[string]interface{})
			checkInfo := tmp["v_checkinfo"].(map[string]interface{})
			if pList, o := info["purchasinglist"].([]interface{}); o {
				pNum += len(pList)
				if tmp["b_isEff"].(bool) {
					pEffNum += 1
				}
				for _, p := range pList {
					p1 := p.(map[string]interface{})
					for f := range purchasingField {
						if qu.ObjToString(p1[f]) != "" {
							fieldNumMap[f] += 1
							if b, o := p1["b_isEff"].(bool); b && o {
								tagNumMap[f] += 1
							}
						}
					}
				}
			}
			if cList, o := checkInfo["purchasinglist"].([]interface{}); o {
				for _, c := range cList {
					c1 := c.(map[string]interface{})
					for f := range purchasingField {

						if qu.IntAll(c1[f]) == 1 {
							rightNumMap[f] += 1
						}
					}
				}
			}
		}
	}
	qu.Debug(cmaps)
	qu.Debug(umaps)
	pResult := method(fieldNumMap, tagNumMap, rightNumMap)
	var userSelect []string
	var dataSelect []map[string]interface{}
	userSelect = append(userSelect, "全部")
	tmp := make(map[string]interface{})
	tmp["name"] = "全部"
	tmp["num1"] = allNum
	tmp["num2"] = checkNum
	tmp["num3"] = checkNumR
	tmp["num4"] = CountPr(checkNumR, checkNum)
	dataSelect = append(dataSelect, tmp)

	sort.Strings(strs)
	for _, v := range strs {
		tmp1 := make(map[string]interface{})
		tmp1["name"] = fs[v]
		tmp1["num1"] = markNum
		tmp1["num2"] = checkNum
		tmp1["num3"] = cmaps[v]
		tmp1["num4"] = CountPr(cmaps[v], checkNum)
		dataSelect = append(dataSelect, tmp1)
	}
	qu.Debug("字段统计---", dataSelect)
	qu.Debug("字段统计---", pResult)
	mp["taskNum"] = allNum
	mp["v_result"] = dataSelect
	mp["v_purchasing"] = pResult
	mp["taskCheckNum"] = checkNum
	mp["taskCheckRight"] = checkNumR
	mp["pNum"] = pNum
	mp["pEffNum"] = pEffNum
}

var modelpath string = "web/model/任务详情%d.xlsx"

// GroupTaskExport 用户组任务导出
func (f *Front) GroupTaskExport() {
	defer qu.Catch()
	starttime, _ := f.GetInt("i_starttime")
	completetime, _ := f.GetInt("i_completetime")
	status := f.GetString("s_status")
	searchStr := f.GetString("s_search")
	search := strings.TrimSpace(searchStr)
	query := map[string]interface{}{
		"s_stype": "group",
	}
	if status != "-1" { //任务状态
		query["s_status"] = status
	}
	if search != "" {
		query["$or"] = []interface{}{
			map[string]interface{}{"s_entname": map[string]interface{}{"$regex": search}},
		}
	}
	if starttime > 0 {
		query["i_starttime"] = map[string]interface{}{
			"$gte": starttime,
		}
	}
	if completetime > 0 {
		query["i_completetime"] = map[string]interface{}{
			"$lte": completetime,
		}
	}
	qu.Debug("Query：", query)
	count := util.Mgo.Count(util.TASKCOLLNAME, query)
	if count > 0 {
		file, err := xlsx.OpenFile("web/model/taskexportmodel.xlsx")
		if err != nil {
			qu.Debug("Load Excel Model Error")
			f.ServeJson("加载脚本失败")
			return
		}
		sheet := file.Sheets[0]
		fields := map[string]interface{}{
			"s_entname":      1,
			"s_departname":   1,
			"s_rulename":     1,
			"s_projectname":  1,
			"s_groupname":    1,
			"s_personname":   1,
			"i_givenum":      1,
			"s_status":       1,
			"i_starttime":    1,
			"i_completetime": 1,
		}
		list, _ := util.Mgo.Find(util.TASKCOLLNAME, query, nil, fields, false, -1, -1)
		qu.Debug(len(*list))
		for _, l := range *list {
			row := sheet.AddRow()
			entname := qu.ObjToString(l["s_entname"])
			departname := qu.ObjToString(l["s_departname"])
			rulename := qu.ObjToString(l["s_rulename"])
			projectname := qu.ObjToString(l["s_projectname"])
			groupname := qu.ObjToString(l["s_groupname"])
			personname := qu.ObjToString(l["s_personname"])
			givenum := qu.IntAll(l["i_givenum"])
			status := qu.ObjToString(l["s_status"])
			starttimestr := ""
			if starttime := qu.Int64All(l["i_starttime"]); starttime != 0 {
				starttimestr = qu.FormatDateByInt64(&starttime, qu.Date_Full_Layout)
			}
			completetimestr := ""
			if completetime := qu.Int64All(l["i_completetime"]); completetime != 0 {
				completetimestr = qu.FormatDateByInt64(&completetime, qu.Date_Full_Layout)
			}
			row.AddCell().SetValue(entname)
			row.AddCell().SetValue(departname)
			row.AddCell().SetValue(rulename)
			row.AddCell().SetValue(projectname)
			row.AddCell().SetValue(groupname)
			row.AddCell().SetValue(personname)
			row.AddCell().SetValue(givenum)
			row.AddCell().SetValue(status)
			row.AddCell().SetValue(starttimestr)
			row.AddCell().SetValue(completetimestr)
		}
		fname := fmt.Sprintf(modelpath, time.Now().Unix())
		qu.Debug("File Name：", fname)
		err = file.Save(fname)
		if err != nil {
			qu.Debug("Save Excel" + fname + "Error")
			f.ServeJson("导出失败")
			return
		}
		arr := strings.Split(fname, "/")
		f.ResponseWriter.Header().Add("Content-Disposition", fmt.Sprintf("attachment; filename=%s", arr[len(arr)-1]))
		f.ServeFile(fname)
		go func(path string) {
			time.Sleep(time.Second * 30)
			os.Remove(path)
		}(fname)
	} else {
		f.ServeJson("没有数据")
	}
}

func (f *Front) GroupStatsTask() {
	defer qu.Catch()
	starttime, _ := f.GetInt("i_starttime")
	completetime, _ := f.GetInt("i_completetime")
	status := f.GetString("s_status")
	searchStr := f.GetString("s_search")
	search := strings.TrimSpace(searchStr)
	query := map[string]interface{}{
		"s_stype": "group",
	}
	if status != "-1" { //任务状态
		query["s_status"] = status
	}
	if search != "" {
		query["$or"] = []interface{}{
			map[string]interface{}{"s_entname": map[string]interface{}{"$regex": search}},
		}
	}
	if starttime > 0 {
		query["i_starttime"] = map[string]interface{}{
			"$gte": starttime,
		}
	}
	if completetime > 0 {
		query["i_completetime"] = map[string]interface{}{
			"$lte": completetime,
		}
	}
	qu.Debug("Query：", query)
	count := util.Mgo.Count(util.TASKCOLLNAME, query)
	if count > 0 {
		var ArrMap []map[string]interface{}
		list, _ := util.Mgo.Find(util.TASKCOLLNAME, query, nil, nil, false, -1, -1)
		for i := 0; i < len(*list); i++ {
			if i == 0 {
				m, _ := Method(nil, (*list)[i])
				ArrMap = append(ArrMap, m)
			} else {
				m, b := Method((*list)[i-1], (*list)[i])
				if b {
					ArrMap = ArrMap[:len(ArrMap)-1] // 删除最后一个
					ArrMap = append(ArrMap, m)
				} else {
					ArrMap = append(ArrMap, m)
				}
			}
		}
		f.T["datasource"] = ArrMap

	}
	_ = f.Render("project/task_list_stats.html")
}

func (f *Front) GroupStatsTaskExport() {
	var data []map[string]interface{}
	dataStr := f.GetString("param")
	err := json.Unmarshal([]byte(dataStr), &data)
	if err != nil {
		qu.Debug("Json Unmarshal Error")
		f.ServeJson(map[string]interface{}{"success": false, "msg": "解析数据失败"})
		return
	}
	file, err := xlsx.OpenFile("web/model/taskstatsmodel.xlsx")
	if err != nil {
		qu.Debug("Load Excel Model Error")
		f.ServeJson(map[string]interface{}{"success": false, "msg": "加载脚本失败"})
		return
	}
	sheet := file.Sheets[0]
	for _, l := range data {
		row := sheet.AddRow()
		projectname := qu.ObjToString(l["s_projectname"])
		groupname := qu.ObjToString(l["s_groupname"])
		datatype := qu.ObjToString(l["s_datatype"])
		num := qu.IntAll(l["num"])
		row.AddCell().SetValue(projectname)
		row.AddCell().SetValue(groupname)
		row.AddCell().SetValue(datatype)
		row.AddCell().SetValue(num)
	}
	fname := fmt.Sprintf("%d.xlsx", time.Now().Unix())
	qu.Debug("File Name：", fname)
	err = file.Save(fname)
	if err != nil {
		qu.Debug("Save Excel" + fname + "Error")
		f.ServeJson(map[string]interface{}{"success": false, "msg": "文件保存失败"})
		return
	}
	arr := strings.Split(fname, "/")
	f.ResponseWriter.Header().Add("Content-Disposition", fmt.Sprintf("attachment; filename=%s", arr[len(arr)-1]))
	f.ServeFile(fname)
	go func(path string) {
		time.Sleep(time.Second * 30)
		os.Remove(path)
	}(fname)
	f.ServeJson(map[string]interface{}{"success": true})
}

func Method(lastTmp, tmp map[string]interface{}) (map[string]interface{}, bool) {
	if qu.ObjToString(tmp["s_datatype"]) == "招标公告" || qu.ObjToString(tmp["s_datatype"]) == "中标公告" {
		if lastTmp == nil {
			m := make(map[string]interface{})
			m["s_projectid"] = tmp["s_projectid"]
			m["s_projectname"] = tmp["s_projectname"]
			m["s_groupname"] = tmp["s_groupname"]
			m["s_datatype"] = tmp["s_datatype"]
			m["num"] = tmp["i_givenum"]
			return m, true
		} else {
			if qu.ObjToString(lastTmp["s_projectid"]) == qu.ObjToString(tmp["s_projectid"]) &&
				qu.ObjToString(lastTmp["s_groupname"]) == qu.ObjToString(tmp["s_groupname"]) {
				lastTmp["num"] = qu.IntAll(lastTmp["num"]) + qu.IntAll(tmp["num"])
				return lastTmp, false
			} else {
				m := make(map[string]interface{})
				m["s_projectid"] = tmp["s_projectid"]
				m["s_projectname"] = tmp["s_projectname"]
				m["s_groupname"] = tmp["s_groupname"]
				m["s_datatype"] = tmp["s_datatype"]
				m["num"] = tmp["i_givenum"]
				return m, true
			}
		}
	} else {
		// 标的物统计
		if lastTmp == nil {
			m := make(map[string]interface{})
			m["s_projectid"] = tmp["s_projectid"]
			m["s_projectname"] = tmp["s_projectname"]
			m["s_groupname"] = tmp["s_groupname"]
			m["s_datatype"] = tmp["s_datatype"]
			m["num"] = Method1(tmp)
			return m, true
		} else {
			if qu.ObjToString(lastTmp["s_projectid"]) == qu.ObjToString(tmp["s_projectid"]) &&
				qu.ObjToString(lastTmp["s_groupname"]) == qu.ObjToString(tmp["s_groupname"]) {
				lastTmp["num"] = qu.IntAll(lastTmp["num"]) + Method1(tmp)
				return lastTmp, false
			} else {
				m := make(map[string]interface{})
				m["s_projectid"] = tmp["s_projectid"]
				m["s_projectname"] = tmp["s_projectname"]
				m["s_groupname"] = tmp["s_groupname"]
				m["s_datatype"] = tmp["s_datatype"]
				m["num"] = Method1(tmp)
				return m, true
			}
		}
	}
}

func Method1(tmp map[string]interface{}) int {
	id := mongodb.BsonIdToSId(tmp["_id"])
	query := map[string]interface{}{"s_groupid": id, "b_isEff": true}
	data, _ := util.Mgo.Find(util.DATACOLLNAME, query, nil, `{"v_baseinfo": 1}`, false, -1, -1)
	if len(*data) > 0 {
		count := 0
		for _, m := range *data {
			if m1, o := m["v_baseinfo"].(map[string]interface{}); o {
				if m2, o1 := m1["purchasinglist"].([]interface{}); o1 {
					for _, m3 := range qu.ObjArrToMapArr(m2) {
						if m3["b_isEff"].(bool) {
							count++
						}
					}
				}
			}
		}
		return count
	}
	return 0
}

func (f *Front) CheckResultWb() {
	defer qu.Catch()
	pid := f.GetString("pid")
	tid := f.GetString("tid")
	if f.Method() == "POST" {
		query := map[string]interface{}{"s_taskid": tid}
		info, _ := util.Mgo.FindOne("f_check_result", query)
		if len(*info) > 0 {
			f.ServeJson(map[string]interface{}{"success": true})
		} else {
			f.ServeJson(map[string]interface{}{"success": false, "msg": "用户组任务未交付"})
		}
	} else {
		query := map[string]interface{}{"s_taskid": tid}
		info, _ := util.Mgo.FindOne("f_check_result", query)

		var userSelect []string
		userSelect = append(userSelect, "全部")

		f.T["pid"] = pid
		f.T["tid"] = tid
		f.T["taskNum"] = (*info)["taskNum"]
		f.T["taskTagNum"] = (*info)["taskNum"]
		f.T["taskCheckNum"] = (*info)["taskCheckNum"]
		f.T["taskCheckRight"] = (*info)["taskCheckRight"]
		f.T["pNum"] = (*info)["pNum"]       // 标的物数量
		f.T["pEffNum"] = (*info)["pEffNum"] //标的物有效数据量
		f.T["tableData"] = map[string]interface{}{"全部": (*info)["v_result"]}
		f.T["pResult"] = (*info)["v_purchasing"]
		f.T["userSelect"] = userSelect
		_ = f.Render("project/check_result.html", &f.T)
	}
}

func (f *Front) GroupExportData() {
	defer qu.Catch()
	appid := f.GetString("appid")
	pici, _ := f.GetInt("pici")
	q := bson.M{"appid": appid, "pici": pici}
	count := util.Mgo.Count(util.DATACOLLNAME, q)
	if count > 0 {
		file, err := xlsx.OpenFile("web/model/taskexportdata.xlsx")
		if err != nil {
			qu.Debug("Load Excel Model Error")
			f.ServeJson("加载文件失败")
			return
		}
		sheet := file.Sheets[0]
		fields := map[string]interface{}{
			"id":                      1,
			"v_baseinfo.package":      1,
			"v_baseinfo.s_winner":     1,
			"v_baseinfo.buyer":        1,
			"v_baseinfo.projectcode":  1,
			"v_baseinfo.projectname":  1,
			"v_baseinfo.title":        1,
			"v_baseinfo.bidamount":    1,
			"v_baseinfo.area":         1,
			"v_baseinfo.city":         1,
			"tagname":                 1,
			"tagname2":                1,
			"v_baseinfo.is_effective": 1,
		}
		list, _ := util.Mgo.Find(util.DATACOLLNAME, q, nil, fields, false, -1, -1)
		for _, l := range *list {
			baseinfo := l["v_baseinfo"].(map[string]interface{})
			if baseinfo["package"] != nil {
				pkg := baseinfo["package"].(map[string]interface{})
				for _, p := range pkg {
					row := sheet.AddRow()
					p1 := p.(map[string]interface{})
					winner := []string{}
					bidamount := float64(0)
					if p1["winner_all"] != nil {
						if all := p1["winner_all"].([]interface{}); all != nil {
							if len(all) > 0 {
								for _, a := range all {
									a1 := a.(map[string]interface{})
									if qu.ObjToString(a1["winner"]) != "" {
										winner = append(winner, qu.ObjToString(a1["winner"]))
									}
									bidamount = qu.Float64All(a1["bidamount"])
								}
							}
						}
					}
					row.AddCell().SetValue(util.SE.EncodeString(qu.ObjToString(l["id"])))
					row.AddCell().SetValue(strings.Join(winner, ","))
					row.AddCell().SetValue(qu.ObjToString(baseinfo["buyer"]))
					row.AddCell().SetValue(qu.ObjToString(baseinfo["projectcode"]))
					row.AddCell().SetValue(qu.ObjToString(baseinfo["projectname"]))
					row.AddCell().SetValue(qu.ObjToString(baseinfo["title"]))
					row.AddCell().SetValue(bidamount)
					row.AddCell().SetValue(qu.ObjToString(baseinfo["area"]))
					row.AddCell().SetValue(qu.ObjToString(baseinfo["city"]))
					row.AddCell().SetValue(qu.ObjToString(l["tagname"]))
					row.AddCell().SetValue(qu.ObjToString(l["tagname2"]))
					row.AddCell().SetValue(qu.ObjToString(baseinfo["is_effective"]))
				}
			} else {
				row := sheet.AddRow()
				row.AddCell().SetValue(util.SE.EncodeString(qu.ObjToString(l["id"])))
				row.AddCell().SetValue(qu.ObjToString(baseinfo["s_winner"]))
				row.AddCell().SetValue(qu.ObjToString(baseinfo["buyer"]))
				row.AddCell().SetValue(qu.ObjToString(baseinfo["projectcode"]))
				row.AddCell().SetValue(qu.ObjToString(baseinfo["projectname"]))
				row.AddCell().SetValue(qu.ObjToString(baseinfo["title"]))
				row.AddCell().SetValue(baseinfo["bidamount"])
				row.AddCell().SetValue(qu.ObjToString(baseinfo["area"]))
				row.AddCell().SetValue(qu.ObjToString(baseinfo["city"]))
				row.AddCell().SetValue(qu.ObjToString(l["tagname"]))
				row.AddCell().SetValue(qu.ObjToString(l["tagname2"]))
				row.AddCell().SetValue(qu.ObjToString(baseinfo["is_effective"]))
			}
		}
		fname := fmt.Sprintf(modelpath, time.Now().Unix())
		qu.Debug("File Name：", fname)
		err = file.Save(fname)
		if err != nil {
			qu.Debug("Save Excel" + fname + "Error")
			f.ServeJson("导出失败")
			return
		}
		arr := strings.Split(fname, "/")
		f.ResponseWriter.Header().Add("Content-Disposition", fmt.Sprintf("attachment; filename=%s", arr[len(arr)-1]))
		f.ServeFile(fname)
		go func(path string) {
			time.Sleep(time.Second * 30)
			os.Remove(path)
		}(fname)
	} else {
		f.ServeJson("没有数据")
	}
}

var FieldsMap = map[string]string{
	"是否优选":    "is_push",
	"运营商中标标签": "tagname",
	"主体公司":    "tagname2",
	"中标人":     "s_winner",
	"招标人":     "buyer",
	"中标金额":    "bidamount",
}

func (f *Front) GroupImportData() {
	defer qu.Catch()
	mf, _, err := f.GetFile("xlsx")
	if err != nil {
		f.ServeJson(map[string]interface{}{"success": false, "msg": "数据导入失败"})
	}
	binary, _ := io.ReadAll(mf)
	xls, _ := xlsx.OpenBinary(binary)
	sheet := xls.Sheets[0]
	rows := sheet.Rows
	idcolnum := -1
	cellFieldName := map[int]string{}
	count := 0
	lastid := ""
	c1 := 0 // 多包第n条数据
	for rn, row := range rows {
		update := make(map[string]interface{})
		del := make(map[string]interface{})
		if rn == 0 {
			for index, cell := range row.Cells {
				if cell.Value == "唯一标识" || cell.Value == "信息标识" { //id所在列
					idcolnum = index
				}
				if v := FieldsMap[cell.Value]; v != "" {
					cellFieldName[index] = v
				}
			}
			if idcolnum == -1 {
				break
			}
			continue
		} else {
			id := row.Cells[idcolnum].String()
			id = util.SE.DecodeString(id)
			for i, f := range cellFieldName {
				if val := row.Cells[i].Value; val != "" {
					if f == "is_push" {
						update[f] = qu.IntAll(val)
					} else if f == "multipackage" {
						update[fmt.Sprintf("v_baseinfo.%s", f)] = qu.IntAll(val)
					} else if f == "bidamount" {
						update[fmt.Sprintf("v_baseinfo.%s", f)] = qu.Float64All(val)
					} else {
						update[fmt.Sprintf("v_baseinfo.%s", f)] = val
					}
				} else {
					if f != "is_push" {
						del[fmt.Sprintf("v_baseinfo.%s", f)] = "1"
					}
				}
			}
			if qu.IntAll(update["v_baseinfo.multipackage"]) == 1 {
				if c1 == 0 {
					count++
				}
				if c1 > 0 && lastid == id {
					info, _ := util.Mgo.FindById(util.DATACOLLNAME, id, bson.M{"v_baseinfo.tagname": 1, "v_baseinfo.tagname2": 1, "v_baseinfo.s_winner": 1,
						"v_baseinfo.bidamount": 1, "v_baseinfo.package": 1})
					if len(*info) > 0 {
						baseinfo := (*info)["v_baseinfo"].(map[string]interface{})
						if baseinfo["package"] != nil {
							packageM := baseinfo["package"].(map[string]interface{})
							m := make(map[string]interface{})
							if update["v_baseinfo.bidamount"] != nil {
								m["bidamount"] = qu.Float64All(update["v_baseinfo.bidamount"])
							}
							if update["v_baseinfo.s_winner"] != nil {
								m["s_winner"] = qu.ObjToString(update["v_baseinfo.s_winner"])
							}
							packageM[fmt.Sprint(c1)] = map[string]interface{}{"winner_all": append([]interface{}{}, m)}
							update["v_baseinfo.package"] = packageM
						}
						if s := qu.ObjToString(baseinfo["tagname"]); s != "" {
							update["v_baseinfo.tagname"] = s + "," + qu.ObjToString(update["v_baseinfo.tagname"])
						}
						if s := qu.ObjToString(baseinfo["tagname2"]); s != "" {
							update["v_baseinfo.tagname2"] = s + "," + qu.ObjToString(update["v_baseinfo.tagname2"])
						}
						if s := qu.ObjToString(baseinfo["s_winner"]); s != "" {
							update["v_baseinfo.s_winner"] = s + "," + qu.ObjToString(update["v_baseinfo.s_winner"])
						}
						update["v_baseinfo.bidamount"] = qu.Float64All(update["v_baseinfo.bidamount"]) + qu.Float64All(baseinfo["bidamount"])
						c1++
					}
				} else {
					c1 = 0
					packageM := make(map[string]interface{})
					m := make(map[string]interface{})
					if update["v_baseinfo.bidamount"] != nil {
						m["bidamount"] = qu.Float64All(update["v_baseinfo.bidamount"])
					}
					if update["v_baseinfo.s_winner"] != nil {
						m["s_winner"] = qu.ObjToString(update["v_baseinfo.s_winner"])
					}
					packageM[fmt.Sprint(c1)] = map[string]interface{}{"winner_all": append([]interface{}{}, m)}
					update["v_baseinfo.package"] = packageM
					c1++
				}
			} else {
				count++
				c1 = 0
			}
			// 临时
			update["tag"] = "临时"
			lastid = id
			if len(del) > 0 {
				util.Mgo.UpdateById(util.DATACOLLNAME, id, bson.M{"$set": update, "$unset": del})
			} else {
				util.Mgo.UpdateById(util.DATACOLLNAME, id, bson.M{"$set": update})
			}
		}
	}
	f.ServeJson(map[string]interface{}{"success": true, "msg": "数据导入成功", "count": count})
}

func (f *Front) StatsTasData() {
	tid := f.GetString("tid")
	if f.Method() == "POST" {
		stype := f.GetString("stype")
		sctype := f.GetString("sctype")
		n1, n2, n3 := countFuc(stype, tid, sctype)
		f.ServeJson(map[string]interface{}{"success": true, "data": bson.M{"num": n1, "pCount": n2, "cCount": n3}})
	} else {
		f.T["taskid"] = tid
		if f.GetString("stype") == "user" {
			f.T["user"] = "user"
			isTagNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_usertaskid": tid, "b_istag": true})               //已标注数量
			allNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_usertaskid": tid})                                  //数据总量
			effNum1 := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_usertaskid": tid, "v_baseinfo.is_efficient": "是"}) // 有效数据 是
			effNum2 := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_usertaskid": tid, "v_baseinfo.is_efficient": "否"}) // 有效数据 否
			effNum3 := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_usertaskid": tid, "v_baseinfo.is_efficient": nil}) // 有效数据 空
			qu.Debug("数据总量：", allNum, "已标注量：", isTagNum)
			f.T["allNum"] = allNum
			f.T["isTagNum"] = isTagNum
			f.T["effNum1"] = effNum1
			f.T["effNum2"] = effNum2
			f.T["effNum3"] = effNum3
		} else if f.GetString("stype") == "group" {
			f.T["group"] = "group"
			//统计数据量
			isTagNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid, "b_istag": true})               //已标注数量
			allNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid})                                  //数据总量``
			effNum1 := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid, "v_baseinfo.is_efficient": "是"}) // 有效数据 是
			effNum2 := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid, "v_baseinfo.is_efficient": "否"}) // 有效数据 否
			effNum3 := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid, "v_baseinfo.is_efficient": nil}) // 有效数据 空
			qu.Debug("数据总量：", allNum, "已标注量：", isTagNum)
			f.T["allNum"] = allNum
			f.T["isTagNum"] = isTagNum
			f.T["effNum1"] = effNum1
			f.T["effNum2"] = effNum2
			f.T["effNum3"] = effNum3
		} else {
			f.T["project"] = "project"
			//统计数据量
			isTagNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid, "b_istag": true})               //已标注数量
			allNum := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid})                                  //数据总量
			effNum1 := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid, "v_baseinfo.is_efficient": "是"}) // 有效数据 是
			effNum2 := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid, "v_baseinfo.is_efficient": "否"}) // 有效数据 否
			effNum3 := util.Mgo.Count(util.DATACOLLNAME, map[string]interface{}{"s_grouptaskid": tid, "v_baseinfo.is_efficient": nil}) // 有效数据 空
			qu.Debug("数据总量：", allNum, "已标注量：", isTagNum)
			f.T["allNum"] = allNum
			f.T["isTagNum"] = isTagNum
			f.T["effNum1"] = effNum1
			f.T["effNum2"] = effNum2
			f.T["effNum3"] = effNum3
		}
		_ = f.Render("project/task_stats.html", &f.T)
	}
}

func countFuc(stype, tid, sctype string) (int, int, int) {
	field := "" //
	q := make(map[string]interface{})
	f := make(map[string]interface{})
	if sctype == "group" {
		q["s_grouptaskid"] = tid
	} else {
		q["s_usertaskid"] = tid
	}
	q["b_istag"] = true
	f["v_baseinfo.is_efficient"] = 1
	if stype == "1" {
		f["v_baseinfo.purchasinglist"] = 1
		field = "purchasinglist"
	} else if stype == "2" {
		f["v_baseinfo.procurementlist"] = 1
		field = "procurementlist"
	} else if stype == "3" {
		f["v_baseinfo.package"] = 1
		field = "v_baseinfo.package"
	}

	sess := util.Mgo.GetMgoConn()
	defer util.Mgo.DestoryMongoConn(sess)

	qu.Debug(q)
	query := sess.DB(util.Mgo.DbName).C(util.DATACOLLNAME).Find(q).Select(f).Iter()
	count := 0
	size, pCount, cCount := 0, 0, 0 //标讯数量， 标的物/多包/意向 累加数量，有效数量
	for tmp := make(map[string]interface{}); query.Next(tmp); count++ {
		if count%2000 == 0 {
			qu.Debug("current ---", count)
		}
		if binfo, ok := tmp["v_baseinfo"].(map[string]interface{}); ok {
			if binfo["is_efficient"] == nil || qu.ObjToString(binfo["is_efficient"]) == "是" {
				if binfo[field] != nil {
					size++
					if field == "package" {
						pCount += len(binfo[field].(map[string]interface{}))
					} else {
						pCount += len(binfo[field].([]interface{}))
					}
				}
			}
		}
	}
	return size, pCount, cCount
}