zyos_camp_task/app/store/svc/svc_task.go

package svc

import (
	"applet/app/comm/db"
	"applet/app/comm/e"
	"applet/app/comm/svc"
	"applet/app/comm/utils"
	"applet/app/comm/utils/cache"
	"applet/app/store/md"
	"code.fnuoos.com/go_rely_warehouse/zyos_model.git/src/implement"
	"code.fnuoos.com/go_rely_warehouse/zyos_model.git/src/models"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"strings"
	"time"
)

func TaskList(c *gin.Context) {
	var args md.TaskReq
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	store := svc.GetCampStore(c)
	storeId := svc.GetCampStoreId(c)
	list := make([]map[string]string, 0)
	var data = make([]models.CampTaskList, 0)
	contact := []string{"0"}
	if store.Pid > 0 {
		contact = append(contact, utils.IntToStr(store.Id))
	}
	sess := svc.MasterDb(c).Where("store_id=? and is_delete=0", storeId)
	if store.Pid > 0 {
		sess.In("contact", contact)
	}
	if args.TaskType != "" {
		sess.And("first_cid=?", args.TaskType)
	}
	if args.ApplyType != "" {
		sess.And("audit_type=?", args.ApplyType)
	}
	if args.StartTime != "" {
		sess.And("apply_time>=?", args.StartTime)
	}
	if args.EndTime != "" {
		sess.And("apply_time<=?", args.EndTime)
	}
	count, _ := sess.Limit(utils.StrToInt(args.Size), (utils.StrToInt(args.P)-1)*utils.StrToInt(args.Size)).OrderBy("apply_time desc,id desc").FindAndCount(&data)
	applyType := []string{"", "下架申请", "上架申请"}
	stateType := []string{"审核中", "审核通过", "审核拒绝"}
	taskCate := make([]map[string]string, 0)
	taskCateList := make([]models.CampTaskCate, 0)
	svc.MasterDb(c).Where("is_show_store=? and is_show=?", 1, 1).OrderBy("sort desc,id desc").Find(&taskCateList)
	taskAllCate := make([]map[string]interface{}, 0)
	for _, v := range taskCateList {
		if v.Pid > 0 {
			continue
		}
		tmp := map[string]string{
			"name": v.Name, "value": utils.IntToStr(v.Id),
		}
		taskCate = append(taskCate, tmp)
		listTmp := make([]map[string]string, 0)
		allTmp := map[string]interface{}{
			"name": v.Name, "value": utils.IntToStr(v.Id), "list": listTmp,
		}
		taskAllCate = append(taskAllCate, allTmp)
	}
	for _, v := range data {
		orderCount, _ := svc.MasterDb(c).Where("store_id=? and state=1 and task_id=?", v.StoreId, v.Id).Count(&models.CampTaskUserPromotionOrder{})
		tmp := map[string]string{
			"id":          utils.IntToStr(v.Id),
			"name":        v.Name,
			"remark":      v.Remark,
			"num":         utils.IntToStr(v.Num),
			"success_num": utils.Int64ToStr(orderCount),
			"apply_time":  v.ApplyTime.Format("2006-01-02 15:04:05"),
			"price":       v.Price,
			"task_type":   "",
			"apply_type":  applyType[v.AuditType],
			"state":       utils.IntToStr(v.State),
			"state_str":   stateType[v.State],
			"reason":      v.Reason,
		}
		for _, v1 := range taskCate {
			if v1["value"] == utils.IntToStr(v.FirstCid) {
				tmp["task_type"] = v1["name"]
			}
		}
		if v.State != 2 {
			tmp["reason"] = ""
		}
		list = append(list, tmp)
	}
	for k, v := range taskAllCate {
		listTmp := make([]map[string]string, 0)
		for _, v1 := range taskCateList {
			if v["value"] != utils.IntToStr(v1.Pid) {
				continue
			}
			allTmp := map[string]string{
				"name": v1.Name, "value": utils.IntToStr(v1.Id),
			}
			listTmp = append(listTmp, allTmp)
		}
		taskAllCate[k]["list"] = listTmp
	}
	director_list_map := make([]models.CampTaskStoreUser, 0)
	director_list := make([]map[string]string, 0)
	svc.MasterDb(c).Where("pid=?", storeId).Find(&director_list_map)
	for _, v := range director_list_map {
		tmp := map[string]string{"name": v.Name, "value": utils.IntToStr(v.Id)}
		director_list = append(director_list, tmp)
	}
	res := map[string]interface{}{
		"list":          list,
		"task_type":     taskCate,
		"director_list": director_list,
		"apply_type": []map[string]string{
			{"name": "上架申请", "value": "2"},
			{"name": "下架申请", "value": "1"},
		},
		"total": count,
	}
	e.OutSuc(c, res, nil)
	return
}
func TaskBase(c *gin.Context) {
	taskCate := make([]map[string]string, 0)
	taskCateList := make([]models.CampTaskCate, 0)
	svc.MasterDb(c).Where("is_show_store=? and is_show=?", 1, 1).OrderBy("sort desc,id desc").Find(&taskCateList)
	taskAllCate := make([]map[string]interface{}, 0)
	for _, v := range taskCateList {
		if v.Pid > 0 {
			continue
		}
		tmp := map[string]string{
			"name": v.Name, "value": utils.IntToStr(v.Id),
		}
		taskCate = append(taskCate, tmp)
		listTmp := make([]map[string]string, 0)
		allTmp := map[string]interface{}{
			"name": v.Name, "value": utils.IntToStr(v.Id), "list": listTmp,
		}
		taskAllCate = append(taskAllCate, allTmp)
	}
	for k, v := range taskAllCate {
		listTmp := make([]map[string]string, 0)
		for _, v1 := range taskCateList {
			if v["value"] != utils.IntToStr(v1.Pid) {
				continue
			}
			allTmp := map[string]string{
				"name": v1.Name, "value": utils.IntToStr(v1.Id),
			}
			listTmp = append(listTmp, allTmp)
		}
		taskAllCate[k]["list"] = listTmp
	}
	storeId := svc.GetCampStoreId(c)
	var store models.CampTaskStoreUser
	svc.MasterDb(c).Where("id=?", storeId).Get(&store)
	settleType := []map[string]string{
		{"name": "T+1", "value": "0"},
	}
	if strings.Contains(store.TaskType, "1") {
		settleType = append(settleType, map[string]string{"name": "T+7", "value": "1"})
	}
	if strings.Contains(store.TaskType, "2") {
		settleType = append(settleType, map[string]string{"name": "T+30", "value": "2"})
	}
	res := map[string]interface{}{
		"all_cate_list": taskAllCate,
		"settle_type":   settleType,
		"audit_type": []map[string]string{
			{"name": "待审核", "value": "0"},
			{"name": "审核通过", "value": "1"},
			{"name": "审核拒绝", "value": "2"},
		},
	}
	e.OutSuc(c, res, nil)
	return
}
func TaskDetail(c *gin.Context) {
	var args map[string]string
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	taskDb := implement.NewCampTaskListDb(svc.MasterDb(c))
	task, _ := taskDb.GetCampTaskById(args["id"])
	res := md.TaskDetail{}
	res.Contact = ""
	res.Label = make([]string, 0)
	res.DetailInfo = make([]string, 0)
	if task != nil {
		taskDetailDb := implement.NewCampTaskDetailDb(svc.MasterDb(c))
		taskDetail, _ := taskDetailDb.GetCampTaskDetailById(args["id"])
		res = md.TaskDetail{
			Remark:     task.Remark,
			Id:         utils.IntToStr(task.Id),
			Name:       task.Name,
			Logo:       svc.ImageFormat(c, task.Logo),
			Price:      task.Price,
			Contact:    task.Contact,
			Num:        utils.IntToStr(task.Num),
			FirstCid:   utils.IntToStr(task.FirstCid),
			SecondCid:  utils.IntToStr(task.SecondCid),
			SettleType: utils.IntToStr(task.SettleType),
			StartTime:  task.StartTime.Format("2006-01-02 15:04:05"),
			EndTime:    task.EndTime.Format("2006-01-02 15:04:05"),
		}
		if taskDetail != nil {
			DetailInfo := make([]string, 0)
			json.Unmarshal([]byte(taskDetail.DetailInfo), &DetailInfo)
			res.DetailInfo = DetailInfo
			res.VideoCourse = taskDetail.VideoCourse
			res.Notice = taskDetail.Notice
			res.Instructions = taskDetail.Instructions
		}
		NewCampTaskNoticeDb := implement.NewCampTaskNoticeDb(svc.MasterDb(c))
		CampTaskNotice, _ := NewCampTaskNoticeDb.GetCampTaskNoticeByTaskId(args["id"])
		if CampTaskNotice != nil {
			res.Announcement = CampTaskNotice.Content
		}
		label := make([]string, 0)
		json.Unmarshal([]byte(task.Label), &label)
		res.Label = label
	}
	e.OutSuc(c, res, nil)
	return
}
func TaskSave(c *gin.Context) {
	var args md.TaskDetail
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	store := svc.GetCampStore(c)
	storeId := svc.GetCampStoreId(c)
	if store.Pid > 0 {
		args.Contact = utils.IntToStr(store.Id)
	}
	if utils.StrToFloat64(args.Num) <= 0 || utils.StrToFloat64(args.Price) <= 0 {
		e.OutErr(c, e.ERR, e.NewErr(400000, "单价或数量不能为空"))
		return
	}

	amountDb := implement.NewCampTaskStoreUserAmountDb(svc.MasterDb(c))
	userAmount, _ := amountDb.GetCampTaskAmountByStoreId(utils.IntToStr(storeId))
	if userAmount == nil {
		e.OutErr(c, e.ERR, e.NewErr(400000, "预存余额不足"))
		return
	}

	// 加锁 防止并发提取
	mutexKey := fmt.Sprintf("%s:camp_task:%d", c.GetString("mid"), storeId)
	withdrawAvailable, err := cache.Do("SET", mutexKey, 1, "EX", 5, "NX")
	if err != nil {
		e.OutErr(c, e.ERR, err)
		return
	}
	if withdrawAvailable != "OK" {
		e.OutErr(c, e.ERR, e.NewErr(400000, "操作过快，请稍后再试"))
		return
	}

	sess := svc.MasterDb(c).NewSession()
	defer sess.Close()
	sess.Begin()
	var task *models.CampTaskList
	var taskDetail *models.CampTaskDetail
	var taskNotice *models.CampTaskNotice
	if utils.StrToInt(args.Id) > 0 {
		taskDb := implement.NewCampTaskListDb(svc.MasterDb(c))
		task, _ = taskDb.GetCampTaskByIdSess(sess, args.Id)
		taskDetailDb := implement.NewCampTaskDetailDb(svc.MasterDb(c))
		taskDetail, _ = taskDetailDb.GetCampTaskDetailByIdSess(sess, args.Id)
		taskNoticeDb := implement.NewCampTaskNoticeDb(svc.MasterDb(c))
		taskNotice, _ = taskNoticeDb.GetCampTaskNoticeByTaskIdSess(sess, args.Id)
		if task.State == 0 {
			sess.Rollback()
			e.OutErr(c, 400, e.NewErr(400, "任务审核中"))
			return
		}
	} else {
		task = &models.CampTaskList{
			CreateTime: time.Now(),
			UpdateTime: time.Now(),
			StoreId:    storeId,
			Contact:    "0",
			Sum:        utils.StrToInt(args.Num),
			Num:        utils.StrToInt(args.Num),
		}
		insert, _ := sess.Insert(task)
		if insert == 0 {
			sess.Rollback()

			e.OutErr(c, 400, e.NewErr(400, "发布失败"))
			return
		}
		taskDetail = &models.CampTaskDetail{
			TaskId: task.Id,
		}
		insert, _ = sess.Insert(taskDetail)
		if insert == 0 {
			sess.Rollback()

			e.OutErr(c, 400, e.NewErr(400, "发布失败"))
			return
		}
		taskNotice = &models.CampTaskNotice{
			TaskId:     task.Id,
			StoreId:    storeId,
			Title:      "任务公告",
			Type:       "announcement",
			CreateTime: time.Now(),
			SendTime:   time.Now(),
		}
		insert, _ = sess.Insert(taskNotice)
		if insert == 0 {
			sess.Rollback()
			e.OutErr(c, 400, e.NewErr(400, "发布失败"))
			return
		}
	}

	cb, err := svc.HandleCampTaskLockDistributedLock(c.GetString("mid"), utils.IntToStr(task.Id), "camp_task")
	if err != nil {
		sess.Rollback()
		e.OutErr(c, e.ERR, e.NewErr(400000, "操作过快，请稍后再试"))
		return
	}
	// 处理完毕释放锁
	if cb != nil {
		defer cb()
	}
	task.State = 0
	task.UpDownState = 0 //要先下架
	task.AuditType = 2
	//判断下要不要改数量
	if task.Num != utils.StrToInt(args.Num) {
		task.AuditType = 3
		task.OldNum = task.Num
	}
	task.Num = utils.StrToInt(args.Num)

	task.UpdateTime = time.Now()
	task.Price = args.Price
	task.Remark = args.Remark
	task.Name = args.Name
	task.Logo = args.Logo
	task.FirstCid = utils.StrToInt(args.FirstCid)
	task.SecondCid = utils.StrToInt(args.SecondCid)
	task.SettleType = utils.StrToInt(args.SettleType)
	task.StartTime = utils.TimeParseStd(args.StartTime)
	task.EndTime = utils.TimeParseStd(args.EndTime)
	task.Label = utils.SerializeStr(args.Label)
	if args.Contact == "" {
		args.Contact = "0"
	}
	task.Contact = args.Contact
	task.UpdateTime = time.Now()
	task.ApplyTime = time.Now()
	taskDetail.Notice = args.Notice
	taskDetail.DetailInfo = utils.SerializeStr(args.DetailInfo)
	taskDetail.VideoCourse = args.VideoCourse
	taskDetail.Instructions = args.Instructions
	taskNotice.Content = args.Announcement
	_, err = sess.Where("id=?", task.Id).Update(task)
	if err != nil {
		sess.Rollback()
		e.OutErr(c, 400, e.NewErr(400, "发布失败"))
		return
	}
	_, err = sess.Where("id=?", taskNotice.Id).Update(taskNotice)
	if err != nil {
		sess.Rollback()
		e.OutErr(c, 400, e.NewErr(400, "发布失败"))
		return
	}
	_, err = sess.Where("id=?", taskDetail.Id).Update(taskDetail)
	if err != nil {
		sess.Rollback()
		e.OutErr(c, 400, e.NewErr(400, "发布失败"))
		return
	}
	if task.SettleType == 0 {
		sql := `select SUM(price*num) as amount from camp_task_list where is_delete=0 and store_id=? and state in(0,1) and settle_type=0 and audit_type in(2,3)`
		nativeString, _ := db.QueryNativeStringWithSession(sess, sql, storeId)
		var amount float64 = 0
		for _, v := range nativeString {
			amount = utils.StrToFloat64(v["amount"])
		}
		if utils.StrToFloat64(userAmount.Amount) < amount {
			sess.Rollback()
			e.OutErr(c, e.ERR, e.NewErr(400000, "预存余额不足"))
			return
		}
	}

	sess.Commit()
	e.OutSuc(c, "success", nil)
	return
}
func TaskUp(c *gin.Context) {
	var args map[string]string
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	storeId := svc.GetCampStoreId(c)
	// 加锁 防止并发提取
	mutexKey := fmt.Sprintf("%s:camp_task_up:%d", c.GetString("mid"), storeId)
	withdrawAvailable, err := cache.Do("SET", mutexKey, 1, "EX", 5, "NX")
	if err != nil {
		e.OutErr(c, e.ERR, err)
		return
	}
	if withdrawAvailable != "OK" {
		e.OutErr(c, e.ERR, e.NewErr(400000, "操作过快，请稍后再试"))
		return
	}
	cb, err := svc.HandleCampTaskLockDistributedLock(c.GetString("mid"), args["id"], "camp_task")
	if err != nil {
		e.OutErr(c, e.ERR, e.NewErr(400000, "操作过快，请稍后再试"))
		return
	}
	// 处理完毕释放锁
	if cb != nil {
		defer cb()
	}
	sess := svc.MasterDb(c).NewSession()
	defer sess.Close()
	sess.Begin()
	taskDb := implement.NewCampTaskListDb(svc.MasterDb(c))
	task, _ := taskDb.GetCampTaskByIdSess(sess, args["id"])
	if task.UpDownState == 1 {
		sess.Rollback()
		e.OutErr(c, 400, e.NewErr(400, "该任务已上架"))
		return
	}
	if task.State == 0 {
		sess.Rollback()
		e.OutErr(c, 400, e.NewErr(400, "该任务正在审核"))
		return
	}
	task.State = 0
	task.AuditType = 2
	task.ApplyTime = time.Now()
	task.UpdateTime = time.Now()
	update, _ := sess.Where("id=?", task.Id).Cols("state,audit_type,apply_time,update_time").Update(task)
	if update == 0 {
		sess.Rollback()
		e.OutErr(c, 400, e.NewErr(400, "上架申请失败"))
		return
	}
	if task.SettleType == 0 {
		sql := `select SUM(price*num) as amount from camp_task_list where is_delete=0 and store_id=? and state in(0,1) and settle_type=0 and audit_type in(2,3)`
		nativeString, _ := db.QueryNativeStringWithSession(sess, sql, storeId)
		var amount float64 = 0
		for _, v := range nativeString {
			amount = utils.StrToFloat64(v["amount"])
		}
		amountDb := implement.NewCampTaskStoreUserAmountDb(svc.MasterDb(c))
		userAmount, _ := amountDb.GetCampTaskAmountByStoreId(utils.IntToStr(storeId))
		if userAmount == nil {
			sess.Rollback()
			e.OutErr(c, e.ERR, e.NewErr(400000, "预存余额不足"))
			return
		}
		if utils.StrToFloat64(userAmount.Amount) < amount {
			sess.Rollback()
			e.OutErr(c, e.ERR, e.NewErr(400000, "预存余额不足"))
			return
		}
	}

	sess.Commit()
	e.OutSuc(c, "success", nil)
	return
}
func TaskDown(c *gin.Context) {
	var args map[string]string
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	taskDb := implement.NewCampTaskListDb(svc.MasterDb(c))
	task, _ := taskDb.GetCampTaskById(args["id"])
	if task.UpDownState == 0 {
		e.OutErr(c, 400, e.NewErr(400, "该任务已下架"))
		return
	}
	if task.State == 0 {
		e.OutErr(c, 400, e.NewErr(400, "该任务正在审核"))
		return
	}
	storeId := svc.GetCampStoreId(c)
	// 加锁 防止并发提取
	mutexKey := fmt.Sprintf("%s:camp_task_down:%d", c.GetString("mid"), storeId)
	withdrawAvailable, err := cache.Do("SET", mutexKey, 1, "EX", 5, "NX")
	if err != nil {
		e.OutErr(c, e.ERR, err)
		return
	}
	if withdrawAvailable != "OK" {
		e.OutErr(c, e.ERR, e.NewErr(400000, "操作过快，请稍后再试"))
		return
	}
	cb, err := svc.HandleCampTaskLockDistributedLock(c.GetString("mid"), args["id"], "camp_task")
	if err != nil {
		e.OutErr(c, e.ERR, e.NewErr(400000, "操作过快，请稍后再试"))
		return
	}
	// 处理完毕释放锁
	if cb != nil {
		defer cb()
	}
	task.State = 0
	task.AuditType = 1
	task.ApplyTime = time.Now()
	task.UpdateTime = time.Now()
	update, _ := svc.MasterDb(c).Where("id=?", task.Id).Cols("state,audit_type,apply_time,update_time").Update(task)
	if update == 0 {
		e.OutErr(c, 400, e.NewErr(400, "上架申请失败"))
		return
	}
	e.OutSuc(c, "success", nil)
	return
}
func TaskUpList(c *gin.Context) {
	var args md.TaskReq
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	storeId := svc.GetCampStoreId(c)
	list := make([]map[string]string, 0)
	var data = make([]models.CampTaskList, 0)
	sess := svc.MasterDb(c).Where("store_id=? and is_delete=0", storeId)
	sess.And("up_down_state=?", 1)
	count, _ := sess.Limit(utils.StrToInt(args.Size), (utils.StrToInt(args.P)-1)*utils.StrToInt(args.Size)).OrderBy("apply_time desc,id desc").FindAndCount(&data)
	for _, v := range data {
		orderCount, _ := svc.MasterDb(c).Where("store_id=? and task_id=?", v.StoreId, v.Id).Count(&models.CampTaskUserPromotionOrder{})
		orderWaitCount, _ := svc.MasterDb(c).Where("store_id=? and state=0 and task_id=?", v.StoreId, v.Id).Count(&models.CampTaskUserPromotionOrder{})
		tmp := map[string]string{
			"id":          utils.IntToStr(v.Id),
			"name":        v.Name,
			"num":         utils.IntToStr(v.Num),
			"sum":         utils.IntToStr(v.Num + int(orderCount)),
			"success_num": utils.Int64ToStr(orderCount),
			"wait_num":    utils.Int64ToStr(orderWaitCount),
			"up_time":     v.AuditTime.Format("2006-01-02 15:04:05"),
			"price":       v.Price,
		}
		list = append(list, tmp)
	}

	res := map[string]interface{}{
		"list":  list,
		"total": count,
	}
	e.OutSuc(c, res, nil)
	return
}

func TaskChangeNum(c *gin.Context) {
	var args map[string]string
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	storeId := svc.GetCampStoreId(c)
	// 加锁 防止并发提取
	mutexKey := fmt.Sprintf("%s:camp_task_change_num:%d", c.GetString("mid"), storeId)
	withdrawAvailable, err := cache.Do("SET", mutexKey, 1, "EX", 5, "NX")
	if err != nil {
		e.OutErr(c, e.ERR, err)
		return
	}
	if withdrawAvailable != "OK" {
		e.OutErr(c, e.ERR, e.NewErr(400000, "操作过快，请稍后再试"))
		return
	}
	cb, err := svc.HandleCampTaskLockDistributedLock(c.GetString("mid"), args["id"], "camp_task")
	if err != nil {
		e.OutErr(c, e.ERR, e.NewErr(400000, "操作过快，请稍后再试"))
		return
	}
	// 处理完毕释放锁
	if cb != nil {
		defer cb()
	}
	sess := svc.MasterDb(c).NewSession()
	defer sess.Close()
	sess.Begin()
	taskDb := implement.NewCampTaskListDb(svc.MasterDb(c))
	task, _ := taskDb.GetCampTaskByIdSess(sess, args["id"])
	if task.State == 0 {
		sess.Rollback()
		e.OutErr(c, 400, e.NewErr(400, "该任务正在审核"))
		return
	}
	if task.Num == utils.StrToInt(args["num"]) {
		sess.Rollback()
		e.OutErr(c, 400, e.NewErr(400, "数量未变化，修改失败"))
		return
	}
	task.OldNum = task.Num
	task.Num = utils.StrToInt(args["num"])
	task.State = 0
	task.UpDownState = 0
	task.AuditType = 3
	task.ApplyTime = time.Now()
	task.UpdateTime = time.Now()
	update, _ := sess.Where("id=?", task.Id).Cols("state,audit_type,apply_time,update_time,old_num").Update(task)
	if update == 0 {
		sess.Rollback()
		e.OutErr(c, 400, e.NewErr(400, "上架申请失败"))
		return
	}
	if task.SettleType == 0 {
		sql := `select SUM(price*num) as amount from camp_task_list where is_delete=0 and store_id=?  and state in(0,1) and settle_type=0 and audit_type in(2,3)`
		nativeString, _ := db.QueryNativeStringWithSession(sess, sql, storeId)
		var amount float64 = 0
		for _, v := range nativeString {
			amount = utils.StrToFloat64(v["amount"])
		}
		amountDb := implement.NewCampTaskStoreUserAmountDb(svc.MasterDb(c))
		userAmount, _ := amountDb.GetCampTaskAmountByStoreId(utils.IntToStr(storeId))
		if userAmount == nil {
			sess.Rollback()
			e.OutErr(c, e.ERR, e.NewErr(400000, "预存余额不足"))
			return
		}
		if utils.StrToFloat64(userAmount.Amount) < amount {
			sess.Rollback()
			e.OutErr(c, e.ERR, e.NewErr(400000, "预存余额不足"))
			return
		}
	}

	sess.Commit()
	e.OutSuc(c, "success", nil)
	return
}
func TaskAllList(c *gin.Context) {
	var args md.TaskReq
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	list := make([]map[string]string, 0)
	var data = make([]models.CampTaskList, 0)
	sess := svc.MasterDb(c).Where("up_down_state=? and is_delete=0", 1)
	if args.TaskType != "" {
		sess.And("first_cid=?", args.TaskType)
	}
	if args.SettleType != "" {
		sess.And("settle_type=?", args.SettleType)
	}
	count, _ := sess.Limit(utils.StrToInt(args.Size), (utils.StrToInt(args.P)-1)*utils.StrToInt(args.Size)).OrderBy("success_num desc,id desc").FindAndCount(&data)
	for _, v := range data {
		tmp := map[string]string{
			"id":    utils.IntToStr(v.Id),
			"name":  v.Name,
			"price": v.Price,
			"num":   utils.IntToStr(v.Num),
			"icon":  svc.ImageFormat(c, v.Logo),
			"timer": v.StartTime.Format("2006-01-02") + "至" + v.EndTime.Format("2006-01-02"),
		}
		list = append(list, tmp)
	}

	res := map[string]interface{}{
		"list":  list,
		"total": count,
	}
	e.OutSuc(c, res, nil)
	return
}
func TaskAllDetail(c *gin.Context) {
	var args map[string]string
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	taskDb := implement.NewCampTaskListDb(svc.MasterDb(c))
	task, _ := taskDb.GetCampTaskById(args["id"])
	res := md.TaskAllDetail{}
	res.Label = make([]string, 0)
	res.DetailInfo = make([]string, 0)
	if task != nil {
		taskDetailDb := implement.NewCampTaskDetailDb(svc.MasterDb(c))
		taskDetail, _ := taskDetailDb.GetCampTaskDetailById(args["id"])
		res = md.TaskAllDetail{
			Id:    utils.IntToStr(task.Id),
			Name:  task.Name,
			Icon:  svc.ImageFormat(c, task.Logo),
			Price: task.Price,
			Num:   utils.IntToStr(task.Num),
			Timer: task.StartTime.Format("2006-01-02") + "至" + task.EndTime.Format("2006-01-02"),
		}
		if taskDetail != nil {
			DetailInfo := make([]string, 0)
			json.Unmarshal([]byte(taskDetail.DetailInfo), &DetailInfo)
			res.DetailInfo = DetailInfo
		}
		label := make([]string, 0)
		json.Unmarshal([]byte(task.Label), &label)
		res.Label = label
	}
	e.OutSuc(c, res, nil)
	return
}