data_validation/src/front/user.go

package front

import (
	"encoding/json"
	"fmt"
	"github.com/dchest/captcha"
	"github.com/gorilla/sessions"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	mgo "mongodb"
	qu "qfw/util"
	"strconv"
	"strings"
	"sync"
	"time"
	. "util"
)

var store = sessions.NewCookieStore([]byte("jianyu_secret20210422"))

func (f *Front) Login() {
	defer qu.Catch()
	if f.Method() == "POST" {
		username := f.GetString("username")
		password := f.GetString("pwd")
		imgCode := f.GetString("imgCode")
		passwordEn := qu.SE.EncodeString(password)
		qu.Debug(username, passwordEn, imgCode)
		session, err := store.Get(f.Request, "dataTagLoginImgCode")
		if err != nil {
			qu.Debug("图片验证码session获取失败-%s \n", username)
			f.ServeJson(map[string]interface{}{
				"code":    0,
				"status":  false,
				"message": "获取失败",
			})
			return
		}
		code := qu.ObjToString(session.Values["dataTagLoginImgCode"])
		if code == "" {
			qu.Debug("图片验证码过期-%s \n", username)
			f.ServeJson(map[string]interface{}{
				"checked": false,
				"message": "图片验证码过期",
			})
			return
		}
		//if !captcha.VerifyString(code, imgCode) {
		//	qu.Debug("图片验证码错误-%s \n", username)
		//	f.ServeJson(map[string]interface{}{
		//		"checked":  false,
		//		"message": "图片验证码错误",
		//	})
		//	return
		//}
		query := map[string]interface{}{
			"s_login":    username,
			"s_password": passwordEn,
		}
		user, _ := Mgo.FindOne("s_user", query)
		checked := false
		if user != nil && len(*user) > 0 {
			checked = true
			f.SetSession("user", map[string]interface{}{
				"s_groupid": (*user)["s_groupid"],
				"s_name":    (*user)["s_name"],
				"i_role":    (*user)["i_role"],
				"s_pwd":     password,
				"s_login":   username,
				"id":        mgo.BsonIdToSId((*user)["_id"]),
			})
			UserMenu[username] = GetUserMenu(qu.IntAll((*user)["i_role"]))
		}
		f.ServeJson(map[string]interface{}{
			"checked": checked,
			"message": "账号或密码错误",
		})
	} else {
		_ = f.Render("login.html")
	}
}

// Code 获取图片验证码
func (f *Front) Code() {
	id := captcha.NewLen(4)
	//r := &http.Request{}
	f.Request.Header.Add("Cache-Control", "no-cache, no-store, must-revalidate")
	f.Request.Header.Add("Pragma", "no-cache")
	f.Request.Header.Add("Expires", "0")
	f.Request.Header.Add("Content-Type", "image/png")
	w := f.ResponseWriter
	session, err := store.Get(f.Request, "dataTagLoginImgCode")
	if err != nil {
		qu.Debug("session1获取失败")
		return
	}
	session.Values["dataTagLoginImgCode"] = id
	session.Options.MaxAge = 60
	if err := session.Save(f.Request, w); err != nil {
		qu.Debug("session1保存错误,验证码 ", id)
	}
	err2 := captcha.WriteImage(w, id, 90, 30)
	if err2 != nil {
		qu.Debug("生成图片验证码错误,验证码 ", id)
	}
	return
}

func (f *Front) Logout() {
	f.DelSession("user")
	_ = f.Redirect("/")
}

func (f *Front) UserGroup() {
	defer qu.Catch()
	if f.Method() == "POST" {
		start, _ := f.GetInteger("start")
		limit, _ := f.GetInteger("length")
		draw, _ := f.GetInteger("draw")
		searchStr := f.GetString("search[value]")
		search := strings.TrimSpace(searchStr)
		query := map[string]interface{}{
			"b_delete": false,
		}
		if search != "" {
			query["$or"] = []interface{}{
				bson.M{"s_name": bson.M{"$regex": search}},
			}
		}
		data, _ := Mgo.Find("s_group", query, `{"i_createtime":-1}`, nil, false, start, limit)
		count := Mgo.Count("s_group", query)
		f.ServeJson(map[string]interface{}{
			"draw":            draw,
			"data":            data,
			"recordsFiltered": count,
			"recordsTotal":    count,
		})
	} else {
		_ = f.Render("user/user_group.html")
	}
}

func (f *Front) UserGroupNew() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		group := *qu.ObjToMap(data["group"])
		user := *qu.ObjToMap(data["user"])
		currenttime := time.Now().Unix()
		group["i_createtime"] = currenttime
		group["i_updatetime"] = currenttime
		group["b_delete"] = false
		group["i_state"] = true
		gid := Mgo.Save("s_group", group) // 保存用户组
		if gid != "" {
			// 1、用户组管理员账号
			m1 := make(map[string]interface{})
			m1["s_groupid"] = gid
			m1["s_name"] = ""
			m1["s_login"] = group["s_name"]
			m1["s_password"] = qu.SE.EncodeString(qu.ObjToString(group["s_password"]))
			m1["i_role"] = group["i_role"]
			m1["s_phone"] = ""
			m1["i_createtime"] = currenttime
			m1["i_updatetime"] = currenttime
			m1["i_state"] = true
			m1["b_delete"] = false
			m1["check_size"] = qu.IntAll(user["u1_size"])
			m1["user_size"] = qu.IntAll(user["u2_size"])
			Mgo.Save("s_user", m1)
			// 2、质检员账号
			for i := 0; i < qu.IntAll(user["u1_size"]); i++ {
				m := make(map[string]interface{})
				m["s_groupid"] = gid
				m["s_name"] = ""
				m["s_login"] = qu.ObjToString(group["s_name"]) + "_zj_" + strconv.Itoa(i+1)
				m["s_password"] = qu.SE.EncodeString(qu.ObjToString(user["u1_pwd"]))
				m["i_role"] = "3"
				m["s_phone"] = ""
				m["i_createtime"] = currenttime
				m["i_updatetime"] = currenttime
				m["i_state"] = true
				m["b_delete"] = false
				Mgo.Save("s_user", m)
			}
			// 3、普通用户账号
			for i := 0; i < qu.IntAll(user["u2_size"]); i++ {
				m := make(map[string]interface{})
				m["s_groupid"] = gid
				m["s_name"] = ""
				m["s_login"] = qu.ObjToString(group["s_name"]) + "_" + strconv.Itoa(i+1)
				m["s_password"] = qu.SE.EncodeString(qu.ObjToString(user["u2_pwd"]))
				m["i_role"] = "4"
				m["s_phone"] = ""
				m["i_createtime"] = currenttime
				m["i_updatetime"] = currenttime
				m["i_state"] = true
				m["b_delete"] = false
				Mgo.Save("s_user", m)
			}
			f.ServeJson(map[string]interface{}{
				"rep": true,
			})
		} else {
			f.ServeJson(map[string]interface{}{
				"rep": false,
			})
		}
	} else {
		f.T["pwd"] = Password
		_ = f.Render("user/user_group_create.html", &f.T)
	}
}

func (f *Front) GroupModify() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		id := qu.ObjToString(data["id"])
		delete(data, "id")
		qu.Debug(data, id)
		data["i_updatetime"] = time.Now().Unix()
		b := Mgo.UpdateById("s_group", id, map[string]interface{}{"$set": data})
		f.ServeJson(map[string]interface{}{
			"rep": b,
		})
	}
}

func (f *Front) UserGroupState() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		b := Mgo.UpdateById("s_group", qu.ObjToString(data["id"]), map[string]interface{}{"$set": map[string]interface{}{"i_state": data["state"]}})
		f.ServeJson(map[string]interface{}{
			"rep": b,
		})
	}
}

func (f *Front) UserGroupStateBulk() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		qu.Debug(data)
		ids := strings.Split(qu.ObjToString(data["ids"]), ",")
		for _, k := range ids {
			m := map[string]interface{}{"i_state": data["state"], "i_updatetime": time.Now().Unix()}
			b := Mgo.UpdateById("s_group", k, map[string]interface{}{"$set": m})
			if !b {
				f.ServeJson(map[string]interface{}{
					"rep": b,
				})
			}
		}
		f.ServeJson(map[string]interface{}{
			"rep": true,
		})
	}
}

func (f *Front) UserStateBulk() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		ids := strings.Split(qu.ObjToString(data["ids"]), ",")
		for _, k := range ids {
			m := map[string]interface{}{"i_state": data["state"], "i_updatetime": time.Now().Unix()}
			b := Mgo.UpdateById("s_user", k, map[string]interface{}{"$set": m})
			if !b {
				f.ServeJson(map[string]interface{}{
					"rep": b,
				})
			}
		}
		f.ServeJson(map[string]interface{}{
			"rep": true,
		})
	}
}

func (f *Front) UserGroupDel() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		qu.Debug(data)
		m := map[string]interface{}{"b_delete": true, "i_updatetime": time.Now().Unix()}
		b := Mgo.UpdateById("s_group", qu.ObjToString(data["id"]), map[string]interface{}{"$set": m})
		f.ServeJson(map[string]interface{}{
			"rep": b,
		})
	}
}

func (f *Front) UserManage() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		gid := qu.ObjToString(data["gid"])
		draw, _ := f.GetInteger("draw")
		query := map[string]interface{}{"s_groupid": gid, "b_delete": false}
		info, b := Mgo.Find("s_user", query, nil, nil, false, -1, -1)
		count := Mgo.Count("s_user", query)
		if b && len(*info) > 0 {
			f.ServeJson(map[string]interface{}{
				"rep":             true,
				"data":            *info,
				"draw":            draw,
				"recordsFiltered": count,
				"recordsTotal":    count,
			})
		} else {
			f.ServeJson(map[string]interface{}{
				"rep": false,
			})
		}
	} else {
		f.T["gid"] = f.GetString("id")
		_ = f.Render("user/user_list.html", &f.T)
	}
}

func (f *Front) UserState() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		m := map[string]interface{}{"i_state": data["state"], "i_updatetime": time.Now().Unix()}
		b := Mgo.UpdateById("s_user", qu.ObjToString(data["id"]), map[string]interface{}{"$set": m})
		f.ServeJson(map[string]interface{}{
			"rep": b,
		})
	}
}

func (f *Front) UserAll() {
	defer qu.Catch()
	gid := f.GetString("gid")
	if f.Method() == "POST" {
		start, _ := f.GetInteger("start")
		limit, _ := f.GetInteger("length")
		draw, _ := f.GetInteger("draw")
		searchStr := f.GetString("search[value]")
		search := strings.TrimSpace(searchStr)
		query := map[string]interface{}{
			"b_delete": false,
		}
		user := f.GetSession("user").(map[string]interface{})
		if gid == "" {
			if user["i_role"] != "0" && user["i_role"] != "1" {
				query["s_groupid"] = qu.ObjToString(user["s_groupid"])
			}
		} else {
			query["s_groupid"] = gid
		}

		if search != "" {
			query["$or"] = []interface{}{
				bson.M{"s_login": bson.M{"$regex": search}},
			}
		}
		data, _ := Mgo.Find("s_user", query, `{"i_updatetime":-1}`, nil, false, start, limit)
		count := Mgo.Count("s_user", query)
		f.ServeJson(map[string]interface{}{
			"draw":            draw,
			"data":            data,
			"recordsFiltered": count,
			"recordsTotal":    count,
		})
	} else {
		f.T["gid"] = gid
		_ = f.Render("user/user_list.html", &f.T)
	}
}

func (f *Front) UserDel() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		m := map[string]interface{}{"b_delete": true, "i_updatetime": time.Now().Unix()}
		b := Mgo.UpdateById("s_user", qu.ObjToString(data["id"]), map[string]interface{}{"$set": m})
		f.ServeJson(map[string]interface{}{
			"rep": b,
		})
	}
}

func (f *Front) UserModify() {
	defer qu.Catch()
	if f.Method() == "POST" {
		data := GetPostForm(f.Request)
		id := qu.ObjToString(data["id"])
		delete(data, "id")
		data["i_updatetime"] = time.Now().Unix()
		b := Mgo.UpdateById("s_user", id, map[string]interface{}{"$set": map[string]interface{}{"s_name": data["s_name"], "s_phone": data["s_phone"]}})
		f.ServeJson(map[string]interface{}{
			"rep": b,
		})
	}
}

func (f *Front) UserNew() {
	defer qu.Catch()
	if f.Method() == "POST" {
		user := f.GetSession("user").(map[string]interface{})
		role := qu.ObjToString(user["i_role"])
		gid := qu.ObjToString(user["s_groupid"])
		currenttime := time.Now().Unix()
		newUser := make(map[string]interface{})
		var login, pwd = "", ""
		if role == "0" || role == "1" {
			newUser["i_role"] = "1"
			login = f.GetString("login")
			pwd = f.GetString("pwd")
		} else {
			irole := f.GetString("i_role")
			info, _ := Mgo.FindById("s_group", gid, map[string]interface{}{"check_size": 1, "user_size": 1, "s_name": 1})
			if len(*info) > 0 {
				newUser["i_role"] = irole
				if irole == "3" {
					i := qu.IntAll((*info)["check_size"])
					i++
					login = qu.ObjToString((*info)["s_name"]) + "_zj_" + strconv.Itoa(i)
					Mgo.UpdateById("s_group", gid, map[string]interface{}{"$set": map[string]interface{}{"check_size": i}})
				} else if irole == "4" {
					i := qu.IntAll((*info)["user_size"])
					i++
					login = qu.ObjToString((*info)["s_name"]) + "_" + strconv.Itoa(i)
					Mgo.UpdateById("s_group", gid, map[string]interface{}{"$set": map[string]interface{}{"user_size": i}})
				}
				pwd = Password
			}
		}
		newUser["s_name"] = f.GetString("name")
		newUser["s_phone"] = f.GetString("phone")
		newUser["s_groupid"] = gid
		newUser["s_login"] = login
		newUser["s_password"] = qu.SE.EncodeString(pwd)
		newUser["i_createtime"] = currenttime
		newUser["i_updatetime"] = currenttime
		newUser["i_state"] = true
		newUser["b_delete"] = false
		id := Mgo.Save("s_user", newUser)
		if id != "" {
			qu.Debug(id)
			f.ServeJson(map[string]interface{}{
				"rep": true,
			})
		} else {
			f.ServeJson(map[string]interface{}{
				"rep": false,
				"msg": "新增保存失败",
			})
		}
	}
}

func (f *Front) GroupList() {
	qu.Catch()
	query := map[string]interface{}{"b_delete": false, "i_state": true}
	field := map[string]interface{}{"s_name": 1, "s_personname": 1}
	info, b := Mgo.Find("s_group", query, nil, field, false, -1, -1)
	if b && len(*info) > 0 {
		f.ServeJson(map[string]interface{}{
			"rep":  b,
			"data": *info,
		})
	}
}

func (f *Front) UserList() {
	qu.Catch()
	if f.Method() == "POST" {
		user := f.GetSession("user").(map[string]interface{})
		gid := qu.ObjToString(user["s_groupid"])
		query := map[string]interface{}{"s_groupid": gid, "b_delete": false, "i_state": true, "i_role": "4"}
		field := map[string]interface{}{"s_login": 1, "s_groupid": 1, "s_name": 1}
		info, b := Mgo.Find("s_user", query, `{"_id": -1}`, field, false, -1, -1)
		if b && len(*info) > 0 {
			f.ServeJson(map[string]interface{}{
				"rep":  b,
				"data": *info,
			})
		}
	}
}

// UserTaskSave 用户任务分发
func (f *Front) UserTaskSave() {
	defer qu.Catch()
	user := f.GetSession("user").(map[string]interface{})
	username := qu.ObjToString(user["s_login"])
	var taskArr []map[string]interface{}
	var userTaskIdArr []string
	userTaskIdInfo := map[string]Task{}
	success := false
	msg := ""
	groupTaskId := f.GetString("grouptaskid") //用户组任务id
	groupTask, _ := Mgo.FindById(TASKCOLLNAME, groupTaskId, nil)
	if len(*groupTask) == 0 {
		qu.Debug("GroupTask Find Error：", groupTaskId)
		msg = "用户组任务：" + groupTaskId + "查询失败"
		f.ServeJson(map[string]interface{}{"success": false, "msg": msg})
		return
	}
	sourceinfo := qu.ObjToString((*groupTask)["s_sourceinfo"])
	userNums := f.GetString("usernums")
	var userArr []map[string]interface{}
	if err := json.Unmarshal([]byte(userNums), &userArr); err != nil {
		qu.Debug("UserInfo Unmarshal Failed：", err)
		msg = "用户信息解析失败"
	} else {
		for _, userInfo := range userArr {
			userid := qu.ObjToString(userInfo["s_userid"])
			name := qu.ObjToString(userInfo["s_name"]) //可能为空
			login := qu.ObjToString(userInfo["s_login"])
			givenum := qu.IntAll(userInfo["i_givenum"])
			userTaskId := primitive.NewObjectID()
			userTaskIdStr := mgo.BsonIdToSId(userTaskId)
			userTaskIdArr = append(userTaskIdArr, userTaskIdStr)
			ut := Task{
				UserId:   userid,
				GiveNum:  givenum,
				UserName: login,
			}
			userTaskIdInfo[userTaskIdStr] = ut
			userTask := map[string]interface{}{
				"_id":           userTaskId,                                    //生成任务id
				"s_projectid":   qu.ObjToString((*groupTask)["s_projectid"]),   //项目标识
				"s_projectname": qu.ObjToString((*groupTask)["s_projectname"]), //项目名称
				"s_status":      "未开始",                                         //任务状态
				"s_personid":    userid,                                        //任务负责人标识
				"s_personname":  name,                                          //任务负责人
				"s_login":       login,                                         //用户账号
				"s_groupname":   qu.ObjToString((*groupTask)["s_groupname"]),   //用户组名称
				"s_groupid":     qu.ObjToString((*groupTask)["s_groupid"]),     //用户组标识
				"i_givenum":     givenum,                                       //分发数据量
				"s_createname":  username,                                      //创建人
				"i_createtime":  time.Now().Unix(),                             //创建时间
				"s_progress":    "0%",                                          //完成进度
				"s_sourceinfo":  sourceinfo,                                    //源数据表
				"s_stype":       "user",                                        //任务类型
				"s_parentid":    groupTaskId,                                   //父任务及用户组任务id
				"s_entname":     qu.ObjToString((*groupTask)["s_entname"]),     //公司名称
				"s_departname":  qu.ObjToString((*groupTask)["s_departname"]),  //部门名称
				"s_rulename":    qu.ObjToString((*groupTask)["s_rulename"]),    //规则名称
			}
			taskArr = append(taskArr, userTask)
		}
	}
	if len(taskArr) > 0 {
		//分发数据后更新对应用户组任务信息
		success = Mgo.UpdateById(TASKCOLLNAME, groupTaskId, map[string]interface{}{
			"$push": map[string]interface{}{
				"v_sonids": map[string]interface{}{
					"$each": userTaskIdArr,
				},
			},
		})
		if !success {
			msg = "更新用户组任务:" + groupTaskId + "关联用户任务失败"
		} else { //用户分发任务
			success = Mgo.SaveBulk(TASKCOLLNAME, taskArr...)
			if success {
				//用户分发任务后更新该用户组任务的状态和开始时间
				Mgo.Update(TASKCOLLNAME,
					map[string]interface{}{
						"_id":      mgo.StringTOBsonId(groupTaskId),
						"s_status": "未开始",
					},
					map[string]interface{}{
						"$set": map[string]interface{}{
							"s_status":    "进行中",
							"i_starttime": time.Now().Unix(),
						}},
					false, false)
				msg = "任务分发成功"
				UpdateSourceInfoByUser(sourceinfo, groupTaskId, userTaskIdInfo) //用户分发任务成功后，同时更新任务数据源表
			}
		}
	}
	f.ServeJson(map[string]interface{}{"success": success, "msg": msg})
}

// UserTaskList 用户任务列表
func (f *Front) UserTaskList() {
	defer qu.Catch()
	user := f.GetSession("user").(map[string]interface{})
	s_role := qu.ObjToString(user["i_role"])
	s_personid := qu.ObjToString(user["id"])
	gid := qu.ObjToString(user["s_groupid"])
	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)
		query := map[string]interface{}{
			"s_stype": "user",
		}
		if s_role == "4" {
			query["s_personid"] = s_personid
		} else if s_role == "2" {
			query["s_groupid"] = gid
		}
		if status != "-1" { //任务状态
			query["s_status"] = status
		}
		if search != "" {
			query["$or"] = []interface{}{
				map[string]interface{}{"s_projectname": map[string]interface{}{"$regex": search}},
			}
		}
		count := Mgo.Count(TASKCOLLNAME, query)
		qu.Debug("Query：", query, count)
		list, _ := Mgo.Find(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"])
				sourceinfo := qu.ObjToString(l["s_sourceinfo"])
				tagNum := Mgo.Count(sourceinfo, map[string]interface{}{"s_usertaskid": mgo.BsonIdToSId(l["_id"]), "b_istag": true})
				progressFloat := float64(tagNum) / float64(giveNum)
				value, _ := strconv.ParseFloat(fmt.Sprintf("%.4f", progressFloat), 64)
				progress := fmt.Sprint(value*100) + "%"
				l["s_progress"] = progress
				//同步数据库
				Mgo.UpdateById(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_user_list.html", &f.T)
	}
}

// UserTaskRetrieve 用户任务收回
func (f *Front) UserTaskRetrieve() {
	defer qu.Catch()
	user := f.GetSession("user").(map[string]interface{})
	username := qu.ObjToString(user["s_login"])
	userTaskId := f.GetString("taskid") //用户任务id
	qu.Debug("User Task Id：", userTaskId)
	sourceInfo := f.GetString("s_sourceinfo") //数据源表
	status := f.GetString("s_status")
	userTaskIdStatus := map[string]string{userTaskId: status}
	msg, count, success := RetrieveCloseTaskByUser(sourceInfo, username, userTaskIdStatus)
	//userTask, _ := Mgo.FindById(TASKCOLLNAME, userTaskId, nil)
	f.ServeJson(map[string]interface{}{"success": success, "count": count, "msg": msg})
}

// UserTaskDeliver 标注完成交付任务
func (f *Front) UserTaskDeliver() {
	defer qu.Catch()
	success := false
	msg := ""
	user := f.GetSession("user").(map[string]interface{})
	username := qu.ObjToString(user["s_login"])
	userTaskId := f.GetString("taskid")                                                                  //用户任务id
	sourceInfo := f.GetString("s_sourceinfo")                                                            //数据源表
	count := Mgo.Count(sourceInfo, map[string]interface{}{"s_usertaskid": userTaskId, "b_istag": false}) //查询是否含有未标注数据
	qu.Debug("User Task Id：", userTaskId, count)
	if count == 0 { //标注完成更新任务状态
		set := map[string]interface{}{
			"s_status":       "已完成", //收回、关闭时默认任务状态已完成
			"i_updatetime":   time.Now().Unix(),
			"s_updateperson": username,
			"i_completetime": time.Now().Unix(),
		}
		success = Mgo.UpdateById(TASKCOLLNAME, userTaskId, map[string]interface{}{"$set": set})
		if !success {
			msg = "更新任务信息失败"
		}
	} else {
		msg = "数据未标注完成"
	}
	f.ServeJson(map[string]interface{}{"success": success, "msg": msg})
}

// UserTaskClose 用户任务关闭
func (f *Front) UserTaskClose() {
	defer qu.Catch()
	user := f.GetSession("user").(map[string]interface{})
	username := qu.ObjToString(user["s_login"])
	userTaskId := f.GetString("taskid") //用户任务id
	qu.Debug("User Task Id：", userTaskId)
	sourceInfo := f.GetString("s_sourceinfo") //数据源表
	status := f.GetString("s_status")
	userTaskIdStatus := map[string]string{userTaskId: status}
	msg, count, success := RetrieveCloseTaskByUser(sourceInfo, username, userTaskIdStatus)
	f.ServeJson(map[string]interface{}{"success": success, "count": count, "msg": msg})
}

// UpdateSourceInfoByUser 用户分发任务成功后更新数据源表
func UpdateSourceInfoByUser(sourceinfo, groupTaskId string, userTaskIdInfo map[string]Task) {
	defer qu.Catch()
	for userTaskId, tInfo := range userTaskIdInfo {
		userId := tInfo.UserId
		num := tInfo.GiveNum
		userName := tInfo.UserName
		sess := Mgo.GetMgoConn()
		defer Mgo.DestoryMongoConn(sess)
		ch := make(chan bool, 5)
		wg := &sync.WaitGroup{}
		lock := &sync.Mutex{}
		query := map[string]interface{}{
			"s_grouptaskid": groupTaskId,
			"b_isgiveuser":  false,
		}
		updateArr := [][]map[string]interface{}{}
		qu.Debug("Query：", query)
		it := sess.DB(Mgo.DbName).C(sourceinfo).Find(&query).Limit(int64(num)).Iter()
		n := 0
		for tmp := make(map[string]interface{}); it.Next(tmp); n++ {
			ch <- true
			wg.Add(1)
			go func(tmp map[string]interface{}) {
				defer func() {
					<-ch
					wg.Done()
				}()
				update := []map[string]interface{}{}
				update = append(update, map[string]interface{}{"_id": tmp["_id"]})
				update = append(update, map[string]interface{}{
					"$set": map[string]interface{}{
						"s_usertaskid": userTaskId,
						"s_userid":     userId,
						"s_login":      userName,
						"b_isgiveuser": true,
						"i_updatetime": time.Now().Unix(),
					},
				})
				lock.Lock()
				updateArr = append(updateArr, update)
				if len(updateArr) > 500 {
					Mgo.UpdateBulk(sourceinfo, updateArr...)
					updateArr = [][]map[string]interface{}{}
				}
				lock.Unlock()
			}(tmp)
			if n%100 == 0 {
				qu.Debug("current:", n)
			}
			tmp = map[string]interface{}{}
		}
		wg.Wait()
		lock.Lock()
		if len(updateArr) > 0 {
			Mgo.UpdateBulk(sourceinfo, updateArr...)
			updateArr = [][]map[string]interface{}{}
		}
		lock.Unlock()
	}
}

// RetrieveCloseTaskByUser 用户收回任务、关闭,更新数据源
func RetrieveCloseTaskByUser(sourceInfo, username string, userTaskIdStatus map[string]string) (allMsg string, allCount int, allSuccess bool) {
	defer qu.Catch()
	allSuccess = true
	for taskId, userTaskStatus := range userTaskIdStatus {
		/*
			收回时userTaskStatus:未开始、进行中
			关闭时userTaskStatus:未开始
		*/
		qu.Debug(taskId, userTaskStatus)
		//用户任务要更新的信息
		taskSet := map[string]interface{}{
			"s_status":       "已完成", //收回、关闭时默认任务状态已完成
			"i_updatetime":   time.Now().Unix(),
			"s_updateperson": username,
			"s_progress":     "100%",
			"i_completetime": time.Now().Unix(),
		}
		if userTaskStatus == "未开始" { //未开始的任务手动添加开始时间
			taskSet["i_starttime"] = time.Now().Unix()
			taskSet["s_status"] = "已关闭"
		}
		query := map[string]interface{}{
			"s_usertaskid": taskId,
			"b_istag":      false,
		}
		count := Mgo.Count(sourceInfo, query)
		qu.Debug("Find Task Id：", taskId, " Retrieve Count：", count)
		if count > 0 { //更新数据源信息
			set := map[string]interface{}{
				"i_updatetime": time.Now().Unix(),
				"b_isgiveuser": false,
			}
			unset := map[string]interface{}{
				"s_usertaskid": "",
				"s_userid":     "",
				"s_login":      "",
			}
			success := Mgo.Update(sourceInfo, query, map[string]interface{}{"$set": set, "$unset": unset}, false, true)
			qu.Debug("Update SourceInfo：", success)
			if success {
				allCount += count
				//收回成功，更新task信息
				success = Mgo.UpdateById(TASKCOLLNAME, taskId, map[string]interface{}{
					"$set": taskSet,
					"$inc": map[string]interface{}{ //更新数据量
						"i_givenum": -count,
					},
				})
				if !success {
					allMsg += "任务ID:" + taskId + "更新数据失败；"
					allSuccess = false
				}
				qu.Debug("Update：", taskId, success)
			} else {
				allMsg += "任务ID:" + taskId + "更新数据源失败；"
				allSuccess = false
			}
		} else { //没有要收回的数据，只更新任务信息
			success := Mgo.UpdateById(TASKCOLLNAME, taskId, map[string]interface{}{
				"$set": taskSet,
			})
			if !success {
				allMsg += "任务ID:" + taskId + "更新数据失败；"
				allSuccess = false
			}
			qu.Debug("Update：", taskId, success)
		}
	}
	return
}