zyos_camp_task/app/operator/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/operator/md"
	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/lib/comm_plan"
	md2 "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/md"
	svc2 "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/svc"
	"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"
	"time"
)

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
	}
	user := svc.GetUser(c)
	update, _ := svc.MasterDb(c).Where("task_id=? and uid=?", args["id"], user.Info.Uid).Count(&models.CampTaskOperatorTask{})
	if update > 0 {
		e.OutErr(c, 400, e.NewErr(400, "该任务已上架"))
		return
	}
	var data = models.CampTaskOperatorTask{
		TaskId:     utils.StrToInt(args["id"]),
		Uid:        user.Info.Uid,
		CreateTime: time.Now(),
	}
	insert, _ := svc.MasterDb(c).Insert(&data)
	if insert == 0 {
		e.OutErr(c, 400, e.NewErr(400, "上架失败"))
		return
	}
	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
	}
	user := svc.GetUser(c)
	update, _ := svc.MasterDb(c).Where("task_id=? and uid=?", args["id"], user.Info.Uid).Delete(&models.CampTaskOperatorTask{})
	if update == 0 {
		e.OutErr(c, 400, e.NewErr(400, "下架失败"))
		return
	}
	e.OutSuc(c, "success", nil)
	return
}
func TaskList(c *gin.Context) {
	var args md.TaskListReq
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	user := svc.GetUser(c)
	hotTask := make([]map[string]interface{}, 0)
	var hotTaskList []models.CampTaskList
	sess := svc.MasterDb(c).Where("up_down_state=?", 1)
	if args.Cid != "" {
		sess.And("first_cid=?", args.Cid)
	}
	if args.SettleType != "" {
		sess.And("settle_type=?", args.SettleType)
	}
	total, _ := sess.Limit(utils.StrToInt(args.P), (utils.StrToInt(args.P)-1)*utils.StrToInt(args.Size)).OrderBy("success_num desc,id desc").FindAndCount(&hotTaskList)
	for _, v := range hotTaskList {
		label := make([]string, 0)
		DetailInfo := make([]string, 0)
		tmp := map[string]interface{}{
			"id":          utils.IntToStr(v.Id),
			"is_check":    "0",
			"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"),
			"detail_info": DetailInfo,
			"label":       label,
		}
		taskDetailDb := implement.NewCampTaskDetailDb(svc.MasterDb(c))
		taskDetail, _ := taskDetailDb.GetCampTaskDetailById(utils.IntToStr(v.Id))
		if taskDetail != nil {
			json.Unmarshal([]byte(taskDetail.DetailInfo), &DetailInfo)
			tmp["detail_info"] = DetailInfo
		}
		json.Unmarshal([]byte(v.Label), &label)
		counts, _ := svc.MasterDb(c).Where("uid=? and task_id=?", user.Info.Uid, v.Id).Count(&models.CampTaskOperatorTask{})
		if counts > 0 {
			tmp["is_check"] = "1"
		}
		hotTask = append(hotTask, tmp)
	}
	taskCate := make([]map[string]string, 0)
	taskCateList := make([]models.CampTaskCate, 0)
	svc.MasterDb(c).Where(" is_show=?", 1).OrderBy("sort desc,id desc").Find(&taskCateList)
	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)
	}
	res := map[string]interface{}{
		"cate_list": taskCate,
		"settle_type": []map[string]string{
			{"name": "T+1", "value": "0"},
			{"name": "T+7", "value": "1"},
			{"name": "月结", "value": "2"},
		},
		"total": total, "list": hotTask,
	}
	e.OutSuc(c, res, nil)
	return
}
func TaskUpList(c *gin.Context) {
	var args md.OperatorTaskReq
	if err := c.ShouldBindJSON(&args); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS)
		return
	}
	user := svc.GetUser(c)
	sqlCount := `select count(*) as count from FROM camp_task_operator_task 
WHERE   uid=%d `

	sqlCount = fmt.Sprintf(sqlCount, user.Info.Uid)
	nativeStringCount, _ := db.QueryNativeString(svc.MasterDb(c), sqlCount)
	var total = 0
	hotTask := make([]map[string]string, 0)
	for _, v := range nativeStringCount {
		total = utils.StrToInt(v["count"])
	}
	sql := `select ctl.name as task_name,ctl.price as price,ctot.create_time,ctl.up_down_state,ctl.is_delete,ctot.id,ctot.task_id
from FROM camp_task_operator_task ctot
LEFT JOIN camp_task_list ctl on ctot.task_id=ctl.id
WHERE ctot.uid=%d  order by ctot.id desc %s`
	sql = fmt.Sprintf(sql, user.Info.Uid, "limit "+utils.IntToStr((utils.StrToInt(args.P)-1)*utils.StrToInt(args.Size))+","+args.Size)
	nativeString, _ := db.QueryNativeString(svc.MasterDb(c), sql)
	plan, commission1, virtualCoinMoneyRate := svc2.GetAllPlan(svc.MasterDb(c), c.GetString("mid"))
	rmd := &md2.CommissionParam{}
	cfg, _ := svc2.GetPlanCfg(svc.MasterDb(c), "camp_task", c.GetString("mid"), plan, commission1, virtualCoinMoneyRate, rmd)
	for _, v := range nativeString {
		firstPrice := "0"
		secondPrice := "0"
		if cfg != nil {
			fee, _, _, _ := svc2.CommFee(utils.StrToFloat64(v["price"]), cfg, "commission", rmd)
			tmpPrice, _, _, _ := comm_plan.CalReturnAmountAndRatio(0, 0, 0, "own", fee, 0, cfg)
			firstPrice = utils.Float64ToStr(tmpPrice)
			tmpPrice1, _, _, _ := comm_plan.CalReturnAmountAndRatio(1, 0, 0, "own", fee, 0, cfg)
			secondPrice = utils.Float64ToStr(tmpPrice1)
		}
		orderCount := "0"
		commission := "0"
		sql1 := `select COUNT(*) as count,SUM(ctupor.amount) as amount
from FROM camp_task_user_promotion_order_relate ctupor
LEFT JOIN camp_task_user_promotion_order ctupo on ctupo.oid=ctupor.oid
WHERE ctupor.uid=%d and ctupo.task_id=%s`
		sql1 = fmt.Sprintf(sql1, user.Info.Uid, v["task_id"])
		queryNativeString, _ := db.QueryNativeString(svc.MasterDb(c), sql1)
		for _, v1 := range queryNativeString {
			orderCount = v1["count"]
			commission = v1["amount"]
		}
		tmp := map[string]string{
			"task_name":    v["task_name"],
			"id":           v["id"],
			"base_price":   v["price"],
			"first_price":  firstPrice,
			"second_price": secondPrice,
			"create_time":  v["create_time"],
			"order_count":  orderCount,
			"commission":   commission,
		}
		hotTask = append(hotTask, tmp)
	}
	task := make([]map[string]string, 0)
	taskList := make([]models.CampTaskList, 0)
	svc.MasterDb(c).Where("state=?", 1).OrderBy("sort desc,id desc").Find(&taskList)
	for _, v := range taskList {
		tmp := map[string]string{
			"name": v.Name, "value": utils.IntToStr(v.Id),
		}
		task = append(task, tmp)
	}

	taskCate := make([]map[string]string, 0)
	taskCateList := make([]models.CampTaskCate, 0)
	svc.MasterDb(c).Where(" is_show=?", 1).OrderBy("sort desc,id desc").Find(&taskCateList)
	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)
	}
	res := map[string]interface{}{
		"total": total, "list": hotTask,
	}
	e.OutSuc(c, res, nil)
	return
}