762 lines
26 KiB
Go
762 lines
26 KiB
Go
package dao
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"go-common/app/admin/main/usersuit/model"
|
|
xsql "go-common/library/database/sql"
|
|
"go-common/library/xstr"
|
|
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
const (
|
|
_inPdGroupSQL = "INSERT INTO pendant_group(name,rank,status) VALUES (?,?,?)"
|
|
_inPdGroupRefSQL = "INSERT INTO pendant_group_ref(gid,pid) VALUES (?,?)"
|
|
_inPdInfoSQL = "INSERT INTO pendant_info(name,image,image_model,status,rank) VALUES (?,?,?,?,?)"
|
|
_inPdPriceSQL = "INSERT INTO pendant_price(pid,type,price) VALUES (?,?,?) ON DUPLICATE KEY UPDATE pid=?,type=?,price=?"
|
|
_inPdPKGSQL = "INSERT INTO user_pendant_pkg(mid,pid,expires,type,status) VALUES (?,?,?,4,1) ON DUPLICATE KEY UPDATE expires = ?, type = 4, status = 1"
|
|
_inPdPKGsSQL = "INSERT INTO user_pendant_pkg(mid,pid,expires,type,status) VALUES %s"
|
|
_inPdEquipSQL = "INSERT INTO user_pendant_equip(mid,pid,expires) VALUES (?,?,?) ON DUPLICATE KEY UPDATE pid = ? ,expires = ?"
|
|
_inPdOperationLogSQL = "INSERT INTO pendant_operation_log(oper_id,mid,pid,source_type,action) VALUES %s"
|
|
_upPdGroupRefSQL = "UPDATE pendant_group_ref SET gid = ? WHERE pid = ?"
|
|
_upPdPKGsSQL = "UPDATE user_pendant_pkg SET expires = CASE id %s END, type = 4, status = 1 WHERE id IN (%s)"
|
|
_upPdGroupSQL = "UPDATE pendant_group SET name=?,rank=?,status=? WHERE id=?"
|
|
_upPdGroupStatusSQL = "UPDATE pendant_group SET status=? WHERE id=?"
|
|
_upPdInfoSQL = "UPDATE pendant_info SET name=?,image=?,image_model=?,status=?,rank=? WHERE id=?"
|
|
_upPdInfoStatusSQL = "UPDATE pendant_info SET status=? WHERE id=?"
|
|
_pdInfoAllSQL = `SELECT i.id,i.name,i.image,i.image_model,i.status,i.rank,g.id,g.name,g.rank FROM pendant_info AS i INNER JOIN pendant_group_ref AS r
|
|
ON i.id = r.pid LEFT JOIN pendant_group AS g ON g.id = r.gid ORDER BY g.rank ,i.rank ASC,i.id DESC LIMIT ?,?`
|
|
_pdGroupInfoTotalSQL = "SELECT COUNT(*) FROM pendant_info INNER JOIN pendant_group_ref ON pendant_info.id = pendant_group_ref.pid"
|
|
_pdGroupsTotalSQL = "SELECT COUNT(*) FROM pendant_group"
|
|
_pdGroupRefsTotalSQL = "SELECT COUNT(*) FROM pendant_group_ref"
|
|
_pdGroupRefsGidTotalSQL = "SELECT COUNT(*) FROM pendant_group_ref WHERE gid = ?"
|
|
_pdGroupsSQL = "SELECT id,name,rank,status FROM pendant_group ORDER BY rank ASC LIMIT ?,?"
|
|
_pdGroupAllSQL = "SELECT id,name,rank,status FROM pendant_group ORDER BY rank ASC"
|
|
_pdGroupIDsSQL = "SELECT id,name,rank,status FROM pendant_group WHERE id IN (%s)"
|
|
_pdGroupIDSQL = "SELECT id,name,rank,status FROM pendant_group WHERE id = ?"
|
|
_pdInfoIDsSQL = "SELECT id,name,image,image_model,status,rank FROM pendant_info WHERE id IN (%s) ORDER BY rank ASC"
|
|
_pdPriceIDsSQL = "SELECT pid,type,price FROM pendant_price WHERE pid IN (%s)"
|
|
_pdGroupRefRanksSQL = "SELECT pr.gid,pr.pid FROM pendant_group_ref AS pr INNER JOIN pendant_group AS pg WHERE pr.gid = pg.id ORDER BY pg.rank ASC LIMIT ?,?"
|
|
_pdGroupRefsSQL = "SELECT pid FROM pendant_group_ref WHERE gid = ? LIMIT ?,?"
|
|
_pdInfoIDSQL = "SELECT id,name,image,image_model,status,rank FROM pendant_info WHERE id = ?"
|
|
_pdInfoAllNoPageSQL = "SELECT id,name,image,image_model,status,rank FROM pendant_info"
|
|
_maxOrderHistorysSQL = "SELECT MAX(id) FROM user_pendant_order"
|
|
_countOrderHistorysSQL = "SELECT COUNT(*) FROM user_pendant_order %s"
|
|
_orderHistorysSQL = "SELECT mid,order_id,pay_id,appid,status,pid,time_length,cost,buy_time,pay_type FROM user_pendant_order %s"
|
|
_pdPKGsUIDSQL = "SELECT mid,pid,expires,type,status,is_vip FROM user_pendant_pkg WHERE mid = ? ORDER BY mtime DESC"
|
|
_pdPKGUIDsSQL = "SELECT id,mid,pid,expires,type,status,is_vip FROM user_pendant_pkg WHERE mid IN (%s) AND pid = ?"
|
|
_pdPKGUIDSQL = "SELECT id,mid,pid,expires,type,status,is_vip FROM user_pendant_pkg WHERE mid = ? AND pid = ?"
|
|
_pdEquipUIDSQL = "SELECT pid,expires FROM user_pendant_equip WHERE mid = ? AND expires >= ?"
|
|
_pdOperationLogTotalSQL = "SELECT MAX(id) FROM pendant_operation_log"
|
|
_pdOperationLogSQL = "SELECT oper_id,action,mid,pid,source_type,ctime,mtime FROM pendant_operation_log ORDER BY mtime DESC LIMIT ?,?"
|
|
)
|
|
|
|
// AddPendantGroup insert pendant group .
|
|
func (d *Dao) AddPendantGroup(c context.Context, pg *model.PendantGroup) (gid int64, err error) {
|
|
var res sql.Result
|
|
if res, err = d.db.Exec(c, _inPdGroupSQL, pg.Name, pg.Rank, pg.Status); err != nil {
|
|
err = errors.Wrapf(err, "AddPendantGroup d.db.Exec(%s,%d)", pg.Name, pg.Rank)
|
|
return
|
|
}
|
|
return res.LastInsertId()
|
|
}
|
|
|
|
// TxAddPendantGroupRef tx insert pendant group ref.
|
|
func (d *Dao) TxAddPendantGroupRef(tx *xsql.Tx, pr *model.PendantGroupRef) (affected int64, err error) {
|
|
var res sql.Result
|
|
if res, err = tx.Exec(_inPdGroupRefSQL, pr.GID, pr.PID); err != nil {
|
|
err = errors.Wrapf(err, "TxAddPendantGroupRef itx.Exec(%d,%d)", pr.GID, pr.PID)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// TxAddPendantInfo insert pendant info.
|
|
func (d *Dao) TxAddPendantInfo(tx *xsql.Tx, pi *model.PendantInfo) (pid int64, err error) {
|
|
var res sql.Result
|
|
if res, err = tx.Exec(_inPdInfoSQL, pi.Name, pi.Image, pi.ImageModel, pi.Status, pi.Rank); err != nil {
|
|
err = errors.Wrapf(err, "TxAddPendantInfo tx.Exec(%s,%s,%s,%d)", pi.Name, pi.Image, pi.ImageModel, pi.Rank)
|
|
return
|
|
}
|
|
return res.LastInsertId()
|
|
}
|
|
|
|
// TxAddPendantPrices insert pendant prices.
|
|
func (d *Dao) TxAddPendantPrices(tx *xsql.Tx, pp *model.PendantPrice) (affected int64, err error) {
|
|
var res sql.Result
|
|
if res, err = tx.Exec(_inPdPriceSQL, pp.PID, pp.TP, pp.Price, pp.PID, pp.TP, pp.Price); err != nil {
|
|
err = errors.Wrapf(err, "TxAddPendantPrices tx.Exec(%d,%d,%d)", pp.PID, pp.TP, pp.Price)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// AddPendantPKG insert pendant pkg.
|
|
func (d *Dao) AddPendantPKG(c context.Context, pkg *model.PendantPKG) (affected int64, err error) {
|
|
var res sql.Result
|
|
if res, err = d.db.Exec(c, _inPdPKGSQL, pkg.UID, pkg.PID, pkg.Expires, pkg.Expires); err != nil {
|
|
err = errors.Wrapf(err, "AddPendantPKG d.db.Exec(%d,%d,%d)", pkg.UID, pkg.PID, pkg.Expires)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// TxAddPendantPKGs multi insert pendant pkg.
|
|
func (d *Dao) TxAddPendantPKGs(tx *xsql.Tx, pkgs []*model.PendantPKG) (affected int64, err error) {
|
|
var (
|
|
uids []int64
|
|
pids map[int64]struct{}
|
|
)
|
|
l := len(pkgs)
|
|
valueStrings := make([]string, 0, l)
|
|
valueArgs := make([]interface{}, 0, l*3)
|
|
pids = make(map[int64]struct{})
|
|
for _, pkg := range pkgs {
|
|
valueStrings = append(valueStrings, "(?,?,?,4,1)")
|
|
valueArgs = append(valueArgs, strconv.FormatInt(pkg.UID, 10))
|
|
valueArgs = append(valueArgs, strconv.FormatInt(pkg.PID, 10))
|
|
valueArgs = append(valueArgs, strconv.FormatInt(pkg.Expires, 10))
|
|
uids = append(uids, pkg.UID)
|
|
pids[pkg.PID] = struct{}{}
|
|
}
|
|
stmt := fmt.Sprintf(_inPdPKGsSQL, strings.Join(valueStrings, ","))
|
|
_, err = tx.Exec(stmt, valueArgs...)
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "TxAddPendantPKGs tx.Exec(%s,%+v)", xstr.JoinInts(uids), reflect.ValueOf(pids).MapKeys())
|
|
}
|
|
return
|
|
}
|
|
|
|
// AddPendantEquip insert pendant equip.
|
|
func (d *Dao) AddPendantEquip(c context.Context, pkg *model.PendantPKG) (affected int64, err error) {
|
|
var res sql.Result
|
|
if res, err = d.db.Exec(c, _inPdEquipSQL, pkg.UID, pkg.PID, pkg.Expires, pkg.PID, pkg.Expires); err != nil {
|
|
err = errors.Wrapf(err, "AddPendantEquip d.db.Exec(%d,%d,%d)", pkg.UID, pkg.PID, pkg.Expires)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// AddPendantOperLog insert pendant operation log.
|
|
func (d *Dao) AddPendantOperLog(c context.Context, oid int64, uids []int64, pid int64, action string) (affected int64, err error) {
|
|
var res sql.Result
|
|
l := len(uids)
|
|
valueStrings := make([]string, 0, l)
|
|
valueArgs := make([]interface{}, 0, l*5)
|
|
for _, uid := range uids {
|
|
valueStrings = append(valueStrings, "(?,?,?,?,?)")
|
|
valueArgs = append(valueArgs, strconv.FormatInt(oid, 10))
|
|
valueArgs = append(valueArgs, strconv.FormatInt(uid, 10))
|
|
valueArgs = append(valueArgs, strconv.FormatInt(pid, 10))
|
|
valueArgs = append(valueArgs, strconv.FormatInt(int64(model.PendantSourceTypeAdmin), 10))
|
|
valueArgs = append(valueArgs, action)
|
|
}
|
|
stmt := fmt.Sprintf(_inPdOperationLogSQL, strings.Join(valueStrings, ","))
|
|
res, err = d.db.Exec(c, stmt, valueArgs...)
|
|
if err != nil {
|
|
err = errors.Errorf("AddPendantOperLog tx.Exec(%s,%d,%s) error(%+v)", xstr.JoinInts(uids), pid, action, err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// TxUpPendantGroupRef update pendant group ref.
|
|
func (d *Dao) TxUpPendantGroupRef(tx *xsql.Tx, gid, pid int64) (affected int64, err error) {
|
|
var res sql.Result
|
|
if res, err = tx.Exec(_upPdGroupRefSQL, gid, pid); err != nil {
|
|
err = errors.Wrapf(err, "UpPendantGroupRef tx.Exec(%d,%d)", gid, pid)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// TxUpPendantPKGs multi update pendant pkg.
|
|
func (d *Dao) TxUpPendantPKGs(tx *xsql.Tx, pkgs []*model.PendantPKG) (affected int64, err error) {
|
|
var ids []int64
|
|
l := len(pkgs)
|
|
valueStrings := make([]string, 0, l)
|
|
valueArgs := make([]interface{}, 0, l*2)
|
|
for _, pkg := range pkgs {
|
|
valueStrings = append(valueStrings, "WHEN ? THEN ? ")
|
|
valueArgs = append(valueArgs, strconv.FormatInt(pkg.ID, 10))
|
|
valueArgs = append(valueArgs, strconv.FormatInt(pkg.Expires, 10))
|
|
ids = append(ids, pkg.ID)
|
|
}
|
|
stmt := fmt.Sprintf(_upPdPKGsSQL, strings.Join(valueStrings, " "), xstr.JoinInts(ids))
|
|
_, err = tx.Exec(stmt, valueArgs...)
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "TxUpPendantPKGs tx.Exec(%s)", xstr.JoinInts(ids))
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpPendantGroup update pendant group.
|
|
func (d *Dao) UpPendantGroup(c context.Context, pg *model.PendantGroup) (affected int64, err error) {
|
|
var res sql.Result
|
|
if res, err = d.db.Exec(c, _upPdGroupSQL, pg.Name, pg.Rank, pg.Status, pg.ID); err != nil {
|
|
err = errors.Wrapf(err, "UpPendantGroup tx.Exec(%s,%d,%d,%d)", pg.Name, pg.Rank, pg.Status, pg.ID)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UpPendantGroupStatus update pendant group status.
|
|
func (d *Dao) UpPendantGroupStatus(c context.Context, gid int64, status int8) (affected int64, err error) {
|
|
var res sql.Result
|
|
if res, err = d.db.Exec(c, _upPdGroupStatusSQL, status, gid); err != nil {
|
|
err = errors.Wrapf(err, "UpPendantGroupStatus tx.Exec(%d,%d)", status, gid)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// TxUpPendantInfo update pendant info.
|
|
func (d *Dao) TxUpPendantInfo(tx *xsql.Tx, pi *model.PendantInfo) (affected int64, err error) {
|
|
var res sql.Result
|
|
if res, err = tx.Exec(_upPdInfoSQL, pi.Name, pi.Image, pi.ImageModel, pi.Status, pi.Rank, pi.ID); err != nil {
|
|
err = errors.Wrapf(err, "TxAddPendantPrices tx.Exec(%s,%s,%s,%d,%d,%d)", pi.Name, pi.Image, pi.ImageModel, pi.Status, pi.Rank, pi.ID)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UpPendantInfoStatus update pendant info status.
|
|
func (d *Dao) UpPendantInfoStatus(c context.Context, pid int64, status int8) (affected int64, err error) {
|
|
var res sql.Result
|
|
if res, err = d.db.Exec(c, _upPdInfoStatusSQL, status, pid); err != nil {
|
|
err = errors.Wrapf(err, "UpPendantGroupStatus tx.Exec(%d,%d)", status, pid)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// PendantInfoAll pendant info all.
|
|
func (d *Dao) PendantInfoAll(c context.Context, pn, ps int) (pis []*model.PendantInfo, pids []int64, err error) {
|
|
var (
|
|
gid, groupRank sql.NullInt64
|
|
groupName sql.NullString
|
|
rows *xsql.Rows
|
|
offset = (pn - 1) * ps
|
|
)
|
|
if rows, err = d.db.Query(c, _pdInfoAllSQL, offset, ps); err != nil {
|
|
err = errors.Wrapf(err, "PendantInfoAll d.db.Query(%d,%d)", offset, ps)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
pi := new(model.PendantInfo)
|
|
if err = rows.Scan(&pi.ID, &pi.Name, &pi.Image, &pi.ImageModel, &pi.Status, &pi.Rank, &gid, &groupName, &groupRank); err != nil {
|
|
err = errors.Wrap(err, "PendantInfoAll row.Scan()")
|
|
return
|
|
}
|
|
pi.GID = gid.Int64
|
|
pi.GroupName = groupName.String
|
|
pi.GroupRank = int16(groupRank.Int64)
|
|
pids = append(pids, pi.ID)
|
|
pis = append(pis, pi)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantGroupInfoTotal pendant group info total.
|
|
func (d *Dao) PendantGroupInfoTotal(c context.Context) (count int64, err error) {
|
|
row := d.db.QueryRow(c, _pdGroupInfoTotalSQL)
|
|
if err = row.Scan(&count); err != nil {
|
|
err = errors.Wrap(err, "d.dao.PendantGroupInfoTotal")
|
|
}
|
|
return
|
|
}
|
|
|
|
// PendantGroupsTotal pendant group total.
|
|
func (d *Dao) PendantGroupsTotal(c context.Context) (count int64, err error) {
|
|
row := d.db.QueryRow(c, _pdGroupsTotalSQL)
|
|
if err = row.Scan(&count); err != nil {
|
|
err = errors.Wrap(err, "d.dao.PendantGroupsTotal")
|
|
}
|
|
return
|
|
}
|
|
|
|
// PendantGroupRefsTotal pendant group refs total.
|
|
func (d *Dao) PendantGroupRefsTotal(c context.Context) (count int64, err error) {
|
|
row := d.db.QueryRow(c, _pdGroupRefsTotalSQL)
|
|
if err = row.Scan(&count); err != nil {
|
|
err = errors.Wrap(err, "d.dao.PendantGroupRefsTotal")
|
|
}
|
|
return
|
|
}
|
|
|
|
// PendantGroupRefsGidTotal pendant group refs total by gid.
|
|
func (d *Dao) PendantGroupRefsGidTotal(c context.Context, gid int64) (count int64, err error) {
|
|
row := d.db.QueryRow(c, _pdGroupRefsGidTotalSQL, gid)
|
|
if err = row.Scan(&count); err != nil {
|
|
err = errors.Wrap(err, "d.dao.PendantGroupRefsGidTotal")
|
|
}
|
|
return
|
|
}
|
|
|
|
// PendantGroups pendant group pagesize.
|
|
func (d *Dao) PendantGroups(c context.Context, pn, ps int) (pgs []*model.PendantGroup, err error) {
|
|
var (
|
|
rows *xsql.Rows
|
|
offset = (pn - 1) * ps
|
|
)
|
|
if rows, err = d.db.Query(c, _pdGroupsSQL, offset, ps); err != nil {
|
|
err = errors.Wrapf(err, "PendantGroups d.db.Query(%d,%d)", offset, ps)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
pg := new(model.PendantGroup)
|
|
if err = rows.Scan(&pg.ID, &pg.Name, &pg.Rank, &pg.Status); err != nil {
|
|
err = errors.Wrap(err, "PendantGroups row.Scan()")
|
|
return
|
|
}
|
|
pgs = append(pgs, pg)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantGroupAll pendant all group .
|
|
func (d *Dao) PendantGroupAll(c context.Context) (pgs []*model.PendantGroup, err error) {
|
|
var rows *xsql.Rows
|
|
if rows, err = d.db.Query(c, _pdGroupAllSQL); err != nil {
|
|
err = errors.Wrap(err, "PendantGroupAll d.db.Query(%d,%d)")
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
pg := new(model.PendantGroup)
|
|
if err = rows.Scan(&pg.ID, &pg.Name, &pg.Rank, &pg.Status); err != nil {
|
|
err = errors.Wrap(err, "PendantGroupAll row.Scan()")
|
|
return
|
|
}
|
|
pgs = append(pgs, pg)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantGroupIDs pendant group in ids.
|
|
func (d *Dao) PendantGroupIDs(c context.Context, ids []int64) (pgs []*model.PendantGroup, err error) {
|
|
var rows *xsql.Rows
|
|
if rows, err = d.db.Query(c, fmt.Sprintf(_pdGroupIDsSQL, xstr.JoinInts(ids))); err != nil {
|
|
err = errors.Wrapf(err, "PendantGroupIDs d.db.Query(%s)", xstr.JoinInts(ids))
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
pg := new(model.PendantGroup)
|
|
if err = rows.Scan(&pg.ID, &pg.Name, &pg.Rank, &pg.Status); err != nil {
|
|
err = errors.Wrap(err, "PendantGroupIDs row.Scan()")
|
|
return
|
|
}
|
|
pgs = append(pgs, pg)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantGroupID pendant group by id.
|
|
func (d *Dao) PendantGroupID(c context.Context, id int64) (pg *model.PendantGroup, err error) {
|
|
row := d.db.QueryRow(c, _pdGroupIDSQL, id)
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "PendantGroupID d.db.Query(%d)", id)
|
|
return
|
|
}
|
|
pg = &model.PendantGroup{}
|
|
if err = row.Scan(&pg.ID, &pg.Name, &pg.Rank, &pg.Status); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
pg = nil
|
|
return
|
|
}
|
|
err = errors.Wrap(err, "PendantGroupID row.Scan")
|
|
}
|
|
return
|
|
}
|
|
|
|
// PendantInfoIDs pendant info in ids.
|
|
func (d *Dao) PendantInfoIDs(c context.Context, ids []int64) (pis []*model.PendantInfo, pim map[int64]*model.PendantInfo, err error) {
|
|
var rows *xsql.Rows
|
|
if rows, err = d.db.Query(c, fmt.Sprintf(_pdInfoIDsSQL, xstr.JoinInts(ids))); err != nil {
|
|
err = errors.Wrapf(err, "PendantInfoIDs d.db.Query(%s)", xstr.JoinInts(ids))
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
pim = make(map[int64]*model.PendantInfo, len(ids))
|
|
for rows.Next() {
|
|
pi := new(model.PendantInfo)
|
|
if err = rows.Scan(&pi.ID, &pi.Name, &pi.Image, &pi.ImageModel, &pi.Status, &pi.Rank); err != nil {
|
|
err = errors.Wrap(err, "PendantInfoIDs row.Scan()")
|
|
return
|
|
}
|
|
pis = append(pis, pi)
|
|
pim[pi.ID] = pi
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantPriceIDs pendant price in ids.
|
|
func (d *Dao) PendantPriceIDs(c context.Context, ids []int64) (ppm map[int64][]*model.PendantPrice, err error) {
|
|
var rows *xsql.Rows
|
|
if rows, err = d.db.Query(c, fmt.Sprintf(_pdPriceIDsSQL, xstr.JoinInts(ids))); err != nil {
|
|
err = errors.Wrapf(err, "PendantPriceIDs d.db.Query(%s)", xstr.JoinInts(ids))
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
ppm = make(map[int64][]*model.PendantPrice, len(ids))
|
|
for rows.Next() {
|
|
pp := new(model.PendantPrice)
|
|
if err = rows.Scan(&pp.PID, &pp.TP, &pp.Price); err != nil {
|
|
err = errors.Wrap(err, "PendantPriceIDs row.Scan()")
|
|
return
|
|
}
|
|
ppm[pp.PID] = append(ppm[pp.PID], pp)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantGroupRefRanks pendant group ref pagesize by rank.
|
|
func (d *Dao) PendantGroupRefRanks(c context.Context, pn, ps int) (prs []*model.PendantGroupRef, err error) {
|
|
var (
|
|
rows *xsql.Rows
|
|
offset = (pn - 1) * ps
|
|
)
|
|
if rows, err = d.db.Query(c, _pdGroupRefRanksSQL, offset, ps); err != nil {
|
|
err = errors.Wrapf(err, "PendantGroupRefRanks d.db.Query(%d,%d)", offset, ps)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
pr := new(model.PendantGroupRef)
|
|
if err = rows.Scan(&pr.GID, &pr.PID); err != nil {
|
|
err = errors.Wrap(err, "PendantGroupRefRanks row.Scan()")
|
|
return
|
|
}
|
|
prs = append(prs, pr)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantGroupPIDs pendant group ref pagesize.
|
|
func (d *Dao) PendantGroupPIDs(c context.Context, gid int64, pn, ps int) (pids []int64, err error) {
|
|
var (
|
|
rows *xsql.Rows
|
|
offset = (pn - 1) * ps
|
|
)
|
|
if rows, err = d.db.Query(c, _pdGroupRefsSQL, gid, offset, ps); err != nil {
|
|
err = errors.Wrapf(err, "PendantGroupPIDs d.db.Query(%d,%d,%d)", gid, offset, ps)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
var pid int64
|
|
for rows.Next() {
|
|
if err = rows.Scan(&pid); err != nil {
|
|
err = errors.Wrap(err, "PendantGroupPIDs row.Scan()")
|
|
return
|
|
}
|
|
pids = append(pids, pid)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantInfoID pendant info.
|
|
func (d *Dao) PendantInfoID(c context.Context, id int64) (pi *model.PendantInfo, err error) {
|
|
row := d.db.QueryRow(c, _pdInfoIDSQL, id)
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "PendantInfoID d.db.QueryRow(%d)", id)
|
|
return
|
|
}
|
|
pi = &model.PendantInfo{}
|
|
if err = row.Scan(&pi.ID, &pi.Name, &pi.Image, &pi.ImageModel, &pi.Status, &pi.Rank); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
pi = nil
|
|
return
|
|
}
|
|
err = errors.Wrap(err, "PendantInfoID row.Scan")
|
|
}
|
|
return
|
|
}
|
|
|
|
// PendantInfoAllNoPage pendant info no page.
|
|
func (d *Dao) PendantInfoAllNoPage(c context.Context) (pis []*model.PendantInfo, err error) {
|
|
var rows *xsql.Rows
|
|
if rows, err = d.db.Query(c, _pdInfoAllNoPageSQL); err != nil {
|
|
err = errors.Wrap(err, "PendantInfoAllOnSale d.db.Query()")
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
pi := new(model.PendantInfo)
|
|
if err = rows.Scan(&pi.ID, &pi.Name, &pi.Image, &pi.ImageModel, &pi.Status, &pi.Rank); err != nil {
|
|
err = errors.Wrap(err, "PendantInfoAllOnSale row.Scan()")
|
|
return
|
|
}
|
|
pis = append(pis, pi)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// BuildOrderInfoSQL build a order sql string.
|
|
func (d *Dao) BuildOrderInfoSQL(c context.Context, arg *model.ArgPendantOrder, tp string) (sql string, values []interface{}) {
|
|
values = make([]interface{}, 0, 5)
|
|
var (
|
|
cond []string
|
|
condStr string
|
|
)
|
|
if arg.UID != 0 {
|
|
cond = append(cond, "mid = ?")
|
|
values = append(values, arg.UID)
|
|
}
|
|
if arg.PID != 0 {
|
|
cond = append(cond, "pid = ?")
|
|
values = append(values, arg.PID)
|
|
}
|
|
if arg.Status != 0 {
|
|
cond = append(cond, "status = ?")
|
|
values = append(values, arg.Status)
|
|
}
|
|
if arg.PayID != "" {
|
|
cond = append(cond, "pay_id = ?")
|
|
values = append(values, arg.PayID)
|
|
}
|
|
if arg.Start != 0 {
|
|
cond = append(cond, "mtime >= ?")
|
|
values = append(values, arg.Start)
|
|
}
|
|
if arg.End != 0 {
|
|
cond = append(cond, "mtime <= ?")
|
|
values = append(values, arg.End)
|
|
}
|
|
if tp == "info" {
|
|
condStr = d.joinStrings(cond)
|
|
if condStr != "" {
|
|
sql = fmt.Sprintf(_orderHistorysSQL+" %s %s ", "WHERE", condStr, "ORDER BY mtime DESC LIMIT ?,?")
|
|
} else {
|
|
sql = fmt.Sprintf(_orderHistorysSQL+" %s ", condStr, "ORDER BY mtime DESC LIMIT ?,?")
|
|
}
|
|
values = append(values, (arg.PN-1)*arg.PS, arg.PS)
|
|
} else if tp == "count" {
|
|
condStr = d.joinStrings(cond)
|
|
if condStr != "" {
|
|
sql = fmt.Sprintf(_countOrderHistorysSQL+" %s", "WHERE", condStr)
|
|
} else {
|
|
sql = fmt.Sprintf(_countOrderHistorysSQL, condStr)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (d *Dao) joinStrings(is []string) string {
|
|
if len(is) == 0 {
|
|
return ""
|
|
}
|
|
if len(is) == 1 {
|
|
return is[0]
|
|
}
|
|
var bfPool = sync.Pool{
|
|
New: func() interface{} {
|
|
return bytes.NewBuffer([]byte{})
|
|
},
|
|
}
|
|
buf := bfPool.Get().(*bytes.Buffer)
|
|
for _, i := range is {
|
|
buf.WriteString(i)
|
|
buf.WriteString(" AND ")
|
|
}
|
|
if buf.Len() > 0 {
|
|
buf.Truncate(buf.Len() - 4)
|
|
}
|
|
s := buf.String()
|
|
buf.Reset()
|
|
bfPool.Put(buf)
|
|
return s
|
|
}
|
|
|
|
// MaxOrderHistory max order history.
|
|
func (d *Dao) MaxOrderHistory(c context.Context) (max int64, err error) {
|
|
row := d.db.QueryRow(c, _maxOrderHistorysSQL)
|
|
if err != nil {
|
|
err = errors.Wrap(err, "MaxOrderHistory d.db.QueryRow()")
|
|
return
|
|
}
|
|
if err = row.Scan(&max); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
max = 0
|
|
return
|
|
}
|
|
err = errors.Wrap(err, "MaxOrderHistory row.Scan")
|
|
}
|
|
return
|
|
}
|
|
|
|
// CountOrderHistory count order history.
|
|
func (d *Dao) CountOrderHistory(c context.Context, arg *model.ArgPendantOrder) (total int64, err error) {
|
|
sqlstr, values := d.BuildOrderInfoSQL(c, arg, "count")
|
|
row := d.db.QueryRow(c, sqlstr, values...)
|
|
if err != nil {
|
|
err = errors.Wrap(err, "CountOrderHistory d.db.QueryRow()")
|
|
return
|
|
}
|
|
if err = row.Scan(&total); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
total = 0
|
|
return
|
|
}
|
|
err = errors.Wrap(err, "CountOrderHistory row.Scan")
|
|
}
|
|
return
|
|
}
|
|
|
|
// OrderHistorys get order historys.
|
|
func (d *Dao) OrderHistorys(c context.Context, arg *model.ArgPendantOrder) (pos []*model.PendantOrder, pids []int64, err error) {
|
|
var rows *xsql.Rows
|
|
sqlstr, values := d.BuildOrderInfoSQL(c, arg, "info")
|
|
if rows, err = d.db.Query(c, sqlstr, values...); err != nil {
|
|
err = errors.Wrap(err, "OrderHistorys d.db.Query()")
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
po := new(model.PendantOrder)
|
|
if err = rows.Scan(&po.UID, &po.OrderID, &po.PayID, &po.AppID, &po.Status, &po.PID, &po.TimeLength, &po.Cost, &po.BuyTime, &po.PayType); err != nil {
|
|
err = errors.Wrap(err, "OrderHistorys row.Scan()")
|
|
return
|
|
}
|
|
pos = append(pos, po)
|
|
pids = append(pids, po.PID)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantPKGs get pendant pkgs.
|
|
func (d *Dao) PendantPKGs(c context.Context, uid int64) (pkgs []*model.PendantPKG, err error) {
|
|
var rows *xsql.Rows
|
|
if rows, err = d.db.Query(c, _pdPKGsUIDSQL, uid); err != nil {
|
|
err = errors.Wrapf(err, "PendantPKGs d.db.Query(%d)", uid)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
pkg := new(model.PendantPKG)
|
|
if err = rows.Scan(&pkg.UID, &pkg.PID, &pkg.Expires, &pkg.TP, &pkg.Status, &pkg.IsVip); err != nil {
|
|
err = errors.Wrap(err, "PendantPKGs row.Scan()")
|
|
return
|
|
}
|
|
pkgs = append(pkgs, pkg)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantPKGUIDs get pendant pkgs by muilti uid.
|
|
func (d *Dao) PendantPKGUIDs(c context.Context, uids []int64, pid int64) (pkgs []*model.PendantPKG, err error) {
|
|
var rows *xsql.Rows
|
|
if rows, err = d.db.Query(c, fmt.Sprintf(_pdPKGUIDsSQL, xstr.JoinInts(uids)), pid); err != nil {
|
|
err = errors.Wrapf(err, "PendantPKGUIDs d.db.Query(%s,%d)", xstr.JoinInts(uids), pid)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
pkg := new(model.PendantPKG)
|
|
if err = rows.Scan(&pkg.ID, &pkg.UID, &pkg.PID, &pkg.Expires, &pkg.TP, &pkg.Status, &pkg.IsVip); err != nil {
|
|
err = errors.Wrap(err, "PendantPKGUIDs row.Scan()")
|
|
return
|
|
}
|
|
pkgs = append(pkgs, pkg)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantPKG get pendant in pkg.
|
|
func (d *Dao) PendantPKG(c context.Context, uid, pid int64) (pkg *model.PendantPKG, err error) {
|
|
row := d.db.QueryRow(c, _pdPKGUIDSQL, uid, pid)
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "PendantPKG d.db.QueryRow(%d,%d)", uid, pid)
|
|
return
|
|
}
|
|
pkg = &model.PendantPKG{}
|
|
if err = row.Scan(&pkg.ID, &pkg.UID, &pkg.PID, &pkg.Expires, &pkg.TP, &pkg.Status, &pkg.IsVip); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
pkg = nil
|
|
return
|
|
}
|
|
err = errors.Wrap(err, "PendantPKG row.Scan")
|
|
}
|
|
return
|
|
}
|
|
|
|
// PendantEquipUID pendant equip by uid.
|
|
func (d *Dao) PendantEquipUID(c context.Context, uid int64) (pkg *model.PendantPKG, err error) {
|
|
row := d.db.QueryRow(c, _pdEquipUIDSQL, uid, time.Now().Unix())
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "PendantEquipUID d.db.QueryRow(%d)", uid)
|
|
return
|
|
}
|
|
pkg = &model.PendantPKG{}
|
|
if err = row.Scan(&pkg.PID, &pkg.Expires); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
pkg = nil
|
|
return
|
|
}
|
|
err = errors.Wrap(err, "PendantEquipUID row.Scan")
|
|
}
|
|
return
|
|
}
|
|
|
|
// PendantOperLog get pendant operation log.
|
|
func (d *Dao) PendantOperLog(c context.Context, pn, ps int) (opers []*model.PendantOperLog, uids []int64, err error) {
|
|
var (
|
|
rows *xsql.Rows
|
|
offset = (pn - 1) * ps
|
|
)
|
|
if rows, err = d.db.Query(c, _pdOperationLogSQL, offset, ps); err != nil {
|
|
err = errors.Wrapf(err, "PendantOperLog d.db.Query(%d,%d)", offset, ps)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
oper := new(model.PendantOperLog)
|
|
if err = rows.Scan(&oper.OID, &oper.Action, &oper.UID, &oper.PID, &oper.SourceType, &oper.CTime, &oper.MTime); err != nil {
|
|
err = errors.Wrap(err, "PendantOperLog row.Scan()")
|
|
return
|
|
}
|
|
opers = append(opers, oper)
|
|
uids = append(uids, oper.UID)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// PendantOperationLogTotal pendant operation log total.
|
|
func (d *Dao) PendantOperationLogTotal(c context.Context) (count int64, err error) {
|
|
row := d.db.QueryRow(c, _pdOperationLogTotalSQL)
|
|
if err = row.Scan(&count); err != nil {
|
|
err = errors.Wrap(err, "d.dao.PendantOperationLogTotal")
|
|
}
|
|
return
|
|
}
|