go-common/app/admin/main/usersuit/http/pendant.go

package http

import (
	"encoding/csv"
	"io/ioutil"
	"strconv"
	"strings"

	"go-common/app/admin/main/usersuit/model"
	"go-common/library/ecode"
	"go-common/library/log"
	bm "go-common/library/net/http/blademaster"
	"go-common/library/net/metadata"
	"go-common/library/xstr"
)

func pendantInfoList(c *bm.Context) {
	arg := new(model.ArgPendantGroupList)
	arg.PN, arg.PS = 1, 20
	if err := c.Bind(arg); err != nil {
		return
	}
	pis, pager, err := svc.PendantInfoList(c, arg)
	if err != nil {
		log.Error("svc.PendantInfoList(%+v) err(%v)", arg, err)
		return
	}
	if len(pis) == 0 {
		httpData(c, nil, pager)
		return
	}
	httpData(c, pis, pager)
}

func pendantInfoID(c *bm.Context) {
	arg := new(struct {
		PID int64 `form:"pid" validate:"required"`
		GID int64 `form:"gid" validate:"required"`
	})
	if err := c.Bind(arg); err != nil {
		return
	}
	pi, err := svc.PendantInfoID(c, arg.PID, arg.GID)
	if err != nil {
		log.Error("svc.PendantInfoID(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpData(c, pi, nil)
}

func pendantGroupID(c *bm.Context) {
	arg := new(struct {
		GID int64 `form:"gid" validate:"required"`
	})
	if err := c.Bind(arg); err != nil {
		return
	}
	pg, err := svc.PendantGroupID(c, arg.GID)
	if err != nil {
		log.Error("svc.PendantGroupID(%+v) err(%v)", arg, err)
		return
	}
	httpData(c, pg, nil)
}

func pendantGroupList(c *bm.Context) {
	arg := new(model.ArgPendantGroupList)
	arg.PN, arg.PS = 1, 20
	if err := c.Bind(arg); err != nil {
		return
	}
	pgs, pager, err := svc.PendantGroupList(c, arg)
	if err != nil {
		log.Error("svc.PendantGroupList(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	if len(pgs) == 0 {
		httpData(c, nil, pager)
		return
	}
	httpData(c, pgs, pager)
}

func pendantGroupAll(c *bm.Context) {
	pgs, err := svc.PendantGroupAll(c)
	if err != nil {
		log.Error("svc.PendantGroupAll() err(%v)", err)
		httpCode(c, err)
		return
	}
	httpData(c, pgs, nil)
}

func pendantInfoAllNoPage(c *bm.Context) {
	pis, err := svc.PendantInfoAllNoPage(c)
	if err != nil {
		log.Error("svc.pendantInfoAllNoPage() err(%v)", err)
		httpCode(c, err)
		return
	}
	httpData(c, pis, nil)
}

func addPendantInfo(c *bm.Context) {
	arg := new(model.ArgPendantInfo)
	if err := c.Bind(arg); err != nil {
		return
	}
	err := svc.AddPendantInfo(c, arg)
	if err != nil {
		log.Error("svc.AddPendantInfo(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpCode(c, nil)
}

func upPendantInfo(c *bm.Context) {
	arg := new(model.ArgPendantInfo)
	if err := c.Bind(arg); err != nil {
		return
	}
	err := svc.UpPendantInfo(c, arg)
	if err != nil {
		log.Error("svc.UpPendantInfo(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpCode(c, nil)
}

func upPendantGroupStatus(c *bm.Context) {
	arg := new(struct {
		GID    int64 `form:"gid" validate:"required"`
		Status int8  `form:"status"`
	})
	if err := c.Bind(arg); err != nil {
		return
	}
	err := svc.UpPendantGroupStatus(c, arg.GID, arg.Status)
	if err != nil {
		log.Error("svc.UpPendantGroupStatus(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpCode(c, nil)
}

func upPendantInfoStatus(c *bm.Context) {
	arg := new(struct {
		PID    int64 `form:"pid" validate:"required"`
		Status int8  `form:"status"`
	})
	if err := c.Bind(arg); err != nil {
		return
	}
	err := svc.UpPendantInfoStatus(c, arg.PID, arg.Status)
	if err != nil {
		log.Error("svc.UpPendantInfoStatus(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpCode(c, nil)
}

func addPendantGroup(c *bm.Context) {
	arg := new(model.ArgPendantGroup)
	if err := c.Bind(arg); err != nil {
		return
	}
	err := svc.AddPendantGroup(c, arg)
	if err != nil {
		log.Error("svc.AddPendantGroup(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpCode(c, nil)
}

func upPendantGroup(c *bm.Context) {
	arg := new(model.ArgPendantGroup)
	if err := c.Bind(arg); err != nil {
		return
	}
	err := svc.UpPendantGroup(c, arg)
	if err != nil {
		log.Error("svc.UpPendantGroup(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpCode(c, nil)
}

func pendantOrders(c *bm.Context) {
	arg := new(model.ArgPendantOrder)
	arg.PN, arg.PS = 1, 20
	if err := c.Bind(arg); err != nil {
		return
	}
	pos, pager, err := svc.PendantOrders(c, arg)
	if err != nil {
		log.Error("svc.PendantOrders(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	if len(pos) == 0 {
		httpData(c, nil, pager)
		return
	}
	httpData(c, pos, pager)
}

func equipPendant(c *bm.Context) {
	arg := new(struct {
		UID int64 `form:"uid" validate:"required"`
		PID int64 `form:"pid" validate:"required"`
	})
	if err := c.Bind(arg); err != nil {
		return
	}
	err := svc.EquipPendant(c, arg.UID, arg.PID)
	if err != nil {
		log.Error("svc.EquipPendant(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpCode(c, nil)
}

func userPendantPKG(c *bm.Context) {
	arg := new(struct {
		UID int64 `form:"uid" validate:"required"`
	})
	if err := c.Bind(arg); err != nil {
		return
	}
	pkg, equip, err := svc.PendantPKG(c, arg.UID)
	if err != nil {
		log.Error("svc.PendantPKG(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpData(c, map[string]interface{}{
		"pkg":   pkg,
		"equip": equip,
	}, nil)
}

func userPKGDetails(c *bm.Context) {
	arg := new(struct {
		UID int64 `form:"uid" validate:"required"`
		PID int64 `form:"pid" validate:"required"`
	})
	if err := c.Bind(arg); err != nil {
		return
	}
	pkgs, err := svc.UserPKGDetails(c, arg.UID, arg.PID)
	if err != nil {
		log.Error("svc.UserPKGDetails(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpData(c, pkgs, nil)
}

func upPendantPKG(c *bm.Context) {
	arg := new(model.ArgPendantPKG)
	if err := c.Bind(arg); err != nil {
		return
	}
	msg := &model.SysMsg{IsMsg: arg.IsMsg, Type: arg.Type, Title: arg.Title, Content: arg.Content, RemoteIP: metadata.String(c, metadata.RemoteIP)}
	err := svc.UpPendantPKG(c, arg.UID, arg.PID, arg.Day, msg, arg.OID)
	if err != nil {
		log.Error("svc.UpPendantPKG(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	httpCode(c, nil)
}

// migrate old pedant info to new db.
func mutliSend(c *bm.Context) {
	var (
		err  error
		data []byte
		uids []int64
	)
	file, _, err := c.Request.FormFile("file")
	if err != nil {
		log.Error("upload err(%v)", err)
		httpCode(c, err)
		return
	}
	defer file.Close()
	data, err = ioutil.ReadAll(file)
	if err != nil {
		log.Error("ioutil.ReadAll err(%v)", err)
		return
	}
	r := csv.NewReader(strings.NewReader(string(data)))
	r.Comma = ','
	records, err := r.ReadAll()
	if err != nil {
		log.Error("r.ReadAll() err(%v)", err)
	}
	var (
		uid   int64
		muids = make(map[int64]struct{}, len(records))
	)
	for _, v := range records {
		if v[0] == "" {
			continue
		}
		if uid, err = strconv.ParseInt(v[0], 10, 64); err != nil {
			log.Error("strconv.ParseInt err(%v)", err)
			continue
		}
		if _, ok := muids[uid]; ok {
			continue
		}
		muids[uid] = struct{}{}
		uids = append(uids, uid)
	}
	if len(uids) == 0 {
		log.Warn("uids is nothing to send pendant")
		httpCode(c, ecode.RequestErr)
		return
	}
	if len(uids) > 1000 {
		httpCode(c, ecode.PendantAboveSendMaxLimit)
		return
	}
	params := c.Request.Form
	pidStr := params.Get("pid")
	dayStr := params.Get("day")
	isMsgStr := params.Get("is_msg")
	title := params.Get("title")
	content := params.Get("content")
	operStr := params.Get("oper_id")
	pid, err := strconv.ParseInt(pidStr, 10, 64)
	if err != nil {
		httpCode(c, ecode.RequestErr)
		return
	}
	day, err := strconv.ParseInt(dayStr, 10, 64)
	if err != nil {
		httpCode(c, ecode.RequestErr)
		return
	}
	isMsg, err := strconv.ParseBool(isMsgStr)
	if err != nil {
		httpCode(c, ecode.RequestErr)
		return
	}
	oid, err := strconv.ParseInt(operStr, 10, 64)
	if err != nil {
		httpCode(c, ecode.RequestErr)
		return
	}
	msg := &model.SysMsg{IsMsg: isMsg, Type: model.MsgTypeCustom, Title: title, Content: content, RemoteIP: metadata.String(c, metadata.RemoteIP)}
	if err = svc.MutliSendPendant(c, uids, pid, day, msg, oid); err != nil {
		log.Error("svc.MutliSendPendant(%s,%d,%d,%v,%d) err(%v)", xstr.JoinInts(uids), pid, day, msg, oid, err)
		httpCode(c, err)
		return
	}
	httpCode(c, nil)
}

func pendantOperlog(c *bm.Context) {
	arg := new(struct {
		PN int `form:"pn"`
		PS int `form:"ps"`
	})
	arg.PN, arg.PS = 1, 20
	if err := c.Bind(arg); err != nil {
		return
	}
	opers, pager, err := svc.PendantOperlog(c, arg.PN, arg.PS)
	if err != nil {
		log.Error("svc.PendantOperlog(%+v) err(%v)", arg, err)
		httpCode(c, err)
		return
	}
	if len(opers) == 0 {
		httpData(c, nil, pager)
		return
	}
	httpData(c, opers, pager)
}