545 lines
20 KiB
Go
545 lines
20 KiB
Go
package dao
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"go-common/app/service/main/member/model"
|
|
xsql "go-common/library/database/sql"
|
|
"go-common/library/log"
|
|
"go-common/library/time"
|
|
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
const (
|
|
_shard = 100
|
|
// base
|
|
_selBaseInfo = "SELECT mid,name,sex,face,sign,rank,birthday FROM user_base_%02d WHERE mid=? "
|
|
_setSex = "INSERT INTO user_base_%02d(mid,sex) VALUES (?,?) ON DUPLICATE KEY UPDATE sex=?"
|
|
_setName = "INSERT INTO user_base_%02d(mid,name) VALUES (?,?) ON DUPLICATE KEY UPDATE name=?"
|
|
_setRank = "INSERT INTO user_base_%02d(mid,rank) VALUES (?,?) ON DUPLICATE KEY UPDATE rank=?"
|
|
_setSign = "INSERT INTO user_base_%02d(mid,sign) VALUES (?,?) ON DUPLICATE KEY UPDATE sign=?"
|
|
_setBirthday = "INSERT INTO user_base_%02d(mid,birthday) VALUES (?,?) ON DUPLICATE KEY UPDATE birthday=?"
|
|
_setFace = "INSERT INTO user_base_%02d(mid,face) VALUES (?,?) ON DUPLICATE KEY UPDATE face=?"
|
|
_setBase = `INSERT INTO user_base_%02d(mid,name,sex,face,sign,rank,birthday) VALUES (?,?,?,?,?,?,?)
|
|
ON DUPLICATE KEY UPDATE name=?,sex=?,face=?,sign=?,rank=?,birthday=?`
|
|
// _exp
|
|
_setExp = "INSERT INTO user_exp_%02d (mid,exp) VALUES(?,?) ON DUPLICATE KEY UPDATE exp=VALUES(exp)"
|
|
_updateExp = "UPDATE user_exp_%02d SET exp=exp+? WHERE mid=?"
|
|
_selExp = "SELECT exp FROM user_exp_%02d where mid=?"
|
|
//user_flag
|
|
_selUserAttr = "SELECT flag FROM user_flag where mid =? and flag & ?= ?"
|
|
_updateUserAttr = "INSERT INTO user_flag(mid,flag) VALUES(?,?) ON DUPLICATE KEY UPDATE flag=flag|?"
|
|
// user_official
|
|
_selOfficials = "SELECT mid,role,title,description FROM user_official WHERE role>0"
|
|
// moral
|
|
_selMoral = "SELECT moral,added,deducted,last_recover_date from user_moral where mid=?"
|
|
|
|
_initMoral = `INSERT IGNORE INTO user_moral (mid,moral,added,deducted,last_recover_date) VALUES(?,?,?,?,?)`
|
|
_updateMoral = `update user_moral set moral=moral+?,added=added+?, deducted=deducted + ? where mid = ?`
|
|
_updateMoralRecoverDate = `update user_moral set last_recover_date = ? where mid = ?`
|
|
|
|
// official
|
|
_setOfficialDoc = `INSERT INTO user_official_doc (mid,name,state,role,title,description,extra,submit_source,submit_time) VALUES (?,?,?,?,?,?,?,?,?)
|
|
ON DUPLICATE KEY UPDATE name=VALUES(name), state=VALUES(state), role=VALUES(role), title=VALUES(title), description=VALUES(description), extra=VALUES(extra), submit_source=VALUES(submit_source), submit_time=VALUES(submit_time)`
|
|
_selOfficialDoc = "SELECT mid,name,state,role,title,description,reject_reason,extra FROM user_official_doc WHERE mid=?"
|
|
_selOfficial = "SELECT role,title,description FROM user_official WHERE mid=? AND role>0"
|
|
|
|
//official addit
|
|
_setOfficialDocAddit = `INSERT INTO user_official_doc_addit (mid,property,vstring) VALUES (?,?,?) ON DUPLICATE KEY UPDATE vstring=VALUES(vstring)`
|
|
|
|
// realname
|
|
_selRealnameInfo = `SELECT id,mid,channel,realname,country,card_type,card,card_md5,status,reason,ctime,mtime FROM realname_info WHERE mid = ? LIMIT 1`
|
|
_selRealnameInfoByCard = `SELECT id,mid,channel,realname,country,card_type,card,card_md5,status,reason,ctime,mtime FROM realname_info WHERE card_md5=? AND status in (0,1) LIMIT 1`
|
|
_selRealnameInfoMidByCards = `SELECT mid,card_md5 FROM realname_info WHERE card_md5 IN (%s) AND status in (0,1)`
|
|
_upsertRealnameInfo = `INSERT INTO realname_info (mid,channel,realname,country,card_type,card,card_md5,status,reason) VALUES (?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE channel=?,realname=?,country=?,card_type=?,card=?,card_md5=?,status=?,reason=?`
|
|
_updateRealnameInfo = `UPDATE realname_info SET status=?,reason=? WHERE mid=?`
|
|
_selRealnameApply = "SELECT id,mid,realname,country,card_type,card_num,card_md5,hand_img,front_img,back_img,status,operator,operator_id,operator_time,remark,remark_status,ctime,mtime FROM realname_apply WHERE mid = ? ORDER BY ID DESC LIMIT 1"
|
|
_insertRealnameApply = `INSERT INTO realname_apply (mid,realname,country,card_type,card_num,card_md5,hand_img,front_img,back_img,status) VALUES (?,?,?,?,?,?,?,?,?,?)`
|
|
_selRealnameApplyImg = "SELECT id,img_data,ctime,mtime FROM realname_apply_img WHERE id = ? LIMIT 1"
|
|
_insertRealnameApplyImg = `INSERT INTO realname_apply_img (img_data) VALUES (?)`
|
|
// alipay
|
|
_selRealnameAlipayApply = "SELECT id,mid,realname,card,img,status,reason,bizno,ctime,mtime FROM realname_alipay_apply WHERE mid = ? ORDER BY ID DESC LIMIT 1"
|
|
_insertRealnameAlipayApply = `INSERT INTO realname_alipay_apply (mid,realname,card,img,status,reason,bizno) VALUES (?,?,?,?,?,?,?)`
|
|
_updateRealnameAlipayApply = `UPDATE realname_alipay_apply SET status=?,reason=? WHERE id=?`
|
|
|
|
// realname old
|
|
_insertOldRealnameApply = `INSERT INTO dede_identification_card_apply (mid,realname,type,card_data,card_for_search,front_img,front_img2,back_img,apply_time,status) VALUES (?,?,?,?,?,?,?,?,?,?)`
|
|
_insertOldRealnameApplyImg = `INSERT INTO dede_identification_card_apply_img (img_data,add_time) VALUES (?,?)`
|
|
)
|
|
|
|
func hit(id int64) int64 {
|
|
return id % _shard
|
|
}
|
|
|
|
// BeginTran begin transcation.
|
|
func (d *Dao) BeginTran(c context.Context) (tx *xsql.Tx, err error) {
|
|
return d.db.Begin(c)
|
|
}
|
|
|
|
// BaseInfo base info of user.
|
|
func (d *Dao) BaseInfo(c context.Context, mid int64) (r *model.BaseInfo, err error) {
|
|
r = &model.BaseInfo{}
|
|
row := d.db.Master().QueryRow(c, fmt.Sprintf(_selBaseInfo, hit(mid)), mid)
|
|
if err = row.Scan(&r.Mid, &r.Name, &r.Sex, &r.Face, &r.Sign, &r.Rank, &r.Birthday); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
r = nil
|
|
err = nil
|
|
return
|
|
}
|
|
err = errors.Wrapf(err, "dao base mid(%d)", mid)
|
|
}
|
|
r.RandFaceURL()
|
|
return
|
|
}
|
|
|
|
// SetBase set base.
|
|
func (d *Dao) SetBase(c context.Context, base *model.BaseInfo) (err error) {
|
|
if _, err = d.db.Exec(c, fmt.Sprintf(_setBase, hit(base.Mid)), base.Mid, base.Name, base.Sex, base.Face, base.Sign,
|
|
base.Rank, base.Birthday, base.Name, base.Sex, base.Face, base.Sign, base.Rank, base.Birthday); err != nil {
|
|
err = errors.Wrapf(err, "dao set base(%v)", base)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetSign set user sign.
|
|
func (d *Dao) SetSign(c context.Context, mid int64, sign string) (err error) {
|
|
if _, err = d.db.Exec(c, fmt.Sprintf(_setSign, hit(mid)), mid, sign, sign); err != nil {
|
|
err = errors.Wrapf(err, "dao set sign mid(%d)", mid)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetName set user name.
|
|
func (d *Dao) SetName(c context.Context, mid int64, name string) (err error) {
|
|
if _, err = d.db.Exec(c, fmt.Sprintf(_setName, hit(mid)), mid, name, name); err != nil {
|
|
err = errors.Wrapf(err, "dao set name mid(%d) name(%s)", mid, name)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetRank set user rank.
|
|
func (d *Dao) SetRank(c context.Context, mid, rank int64) (err error) {
|
|
if _, err = d.db.Exec(c, fmt.Sprintf(_setRank, hit(mid)), mid, rank, rank); err != nil {
|
|
err = errors.Wrapf(err, "dao set rank mid(%d) rank(%d)", mid, rank)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetSex set sex.
|
|
func (d *Dao) SetSex(c context.Context, mid, sex int64) (err error) {
|
|
if _, err = d.db.Exec(c, fmt.Sprintf(_setSex, hit(mid)), mid, sex, sex); err != nil {
|
|
err = errors.Wrapf(err, "dao set sex mid(%d) sex(%d)", mid, sex)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetBirthday set birthday.
|
|
func (d *Dao) SetBirthday(c context.Context, mid int64, birthday time.Time) (err error) {
|
|
if _, err = d.db.Exec(c, fmt.Sprintf(_setBirthday, hit(mid)), mid, birthday, birthday); err != nil {
|
|
err = errors.Wrapf(err, "dao set birthday mid(%d) birthday(%d)", mid, birthday)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetFace set face.
|
|
func (d *Dao) SetFace(c context.Context, mid int64, face string) (err error) {
|
|
if _, err = d.db.Exec(c, fmt.Sprintf(_setFace, hit(mid)), mid, face, face); err != nil {
|
|
err = errors.Wrapf(err, "dao set face mid(%d) face(%v)", mid, face)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ExpDB get user exp from db.
|
|
func (d *Dao) ExpDB(c context.Context, mid int64) (count int64, err error) {
|
|
row := d.db.QueryRow(c, fmt.Sprintf(_selExp, hit(mid)), mid)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
return
|
|
}
|
|
err = errors.Wrapf(err, "dao exp mid(%d)", mid)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetExp set user exp to count.
|
|
func (d *Dao) SetExp(c context.Context, mid, count int64) (affect int64, err error) {
|
|
row, err := d.db.Exec(c, fmt.Sprintf(_setExp, hit(mid)), mid, count)
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "dao set exp mid(%d) exp(%d)", mid, count)
|
|
return
|
|
}
|
|
return row.RowsAffected()
|
|
}
|
|
|
|
// UpdateExp incr user exp by delta.
|
|
func (d *Dao) UpdateExp(c context.Context, mid, delta int64) (affect int64, err error) {
|
|
row, err := d.db.Exec(c, fmt.Sprintf(_updateExp, hit(mid)), delta, mid)
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "dao update exp mid(%d) exp(%d)", mid, delta)
|
|
return
|
|
}
|
|
return row.RowsAffected()
|
|
}
|
|
|
|
// ------------- exp ---------------- //
|
|
|
|
// UserAttrDB get attr.
|
|
func (d *Dao) UserAttrDB(c context.Context, mid int64, attr uint) (hasAttr bool, err error) {
|
|
var flag int8
|
|
row := d.db.QueryRow(c, _selUserAttr, mid, attr, attr)
|
|
if err = row.Scan(&flag); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
return
|
|
}
|
|
err = errors.Wrapf(err, "dao attr mid(%d) attr(%d)", mid, attr)
|
|
}
|
|
hasAttr = true
|
|
return
|
|
}
|
|
|
|
// SetUserAttr update attr .
|
|
func (d *Dao) SetUserAttr(c context.Context, mid int64, attr uint) (err error) {
|
|
if _, err = d.db.Exec(c, _updateUserAttr, mid, attr, attr); err != nil {
|
|
err = errors.Wrapf(err, "dao attr mid(%d) attr(%d)", mid, attr)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// Officials all officials info of user.
|
|
func (d *Dao) Officials(c context.Context) (om map[int64]*model.OfficialInfo, err error) {
|
|
om = make(map[int64]*model.OfficialInfo)
|
|
rows, err := d.db.Query(c, _selOfficials)
|
|
if err != nil {
|
|
err = errors.Wrap(err, "dao officials")
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var mid int64
|
|
o := &model.OfficialInfo{}
|
|
if err = rows.Scan(&mid, &o.Role, &o.Title, &o.Desc); err != nil {
|
|
err = errors.Wrap(err, "dao officials scan")
|
|
return
|
|
}
|
|
om[mid] = o
|
|
}
|
|
return
|
|
}
|
|
|
|
// Official is.
|
|
func (d *Dao) Official(c context.Context, mid int64) (*model.OfficialInfo, error) {
|
|
row := d.db.QueryRow(c, _selOfficial, mid)
|
|
o := &model.OfficialInfo{}
|
|
if err := row.Scan(&o.Role, &o.Title, &o.Desc); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
return nil, nil
|
|
}
|
|
return nil, errors.Wrap(err, "dao official scan")
|
|
}
|
|
return o, nil
|
|
}
|
|
|
|
// MoralDB get user moral from db.
|
|
func (d *Dao) MoralDB(c context.Context, mid int64) (moral *model.Moral, err error) {
|
|
moral = &model.Moral{}
|
|
row := d.db.QueryRow(c, _selMoral, mid)
|
|
if err = row.Scan(&moral.Moral, &moral.Added, &moral.Deducted, &moral.LastRecoverDate); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
moral = nil
|
|
err = nil
|
|
return
|
|
}
|
|
log.Error(" SelMoral row.Scan() error(%v) mid(%v)", err, mid)
|
|
err = errors.Wrapf(err, "dao moral mid(%d)", mid)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// TxMoralDB get user moral from db.
|
|
func (d *Dao) TxMoralDB(tx *xsql.Tx, mid int64) (moral *model.Moral, err error) {
|
|
moral = &model.Moral{}
|
|
row := tx.QueryRow(_selMoral, mid)
|
|
if err = row.Scan(&moral.Moral, &moral.Added, &moral.Deducted, &moral.LastRecoverDate); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
moral = nil
|
|
err = nil
|
|
return
|
|
}
|
|
log.Error(" SelMoral row.Scan() error(%v) mid(%v)", err, mid)
|
|
err = errors.Wrapf(err, "dao moral mid(%d)", mid)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// TxUpdateMoral set user moral.
|
|
func (d *Dao) TxUpdateMoral(tx *xsql.Tx, mid, moral, added, deducted int64) (err error) {
|
|
if _, err = tx.Exec(_updateMoral, moral, added, deducted, mid); err != nil {
|
|
err = errors.Wrapf(err, "TxUpdateMoral mid(%d) moralAdded(%v)", mid, moral)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// TxUpdateMoralRecoverDate update moral recover date.
|
|
func (d *Dao) TxUpdateMoralRecoverDate(tx *xsql.Tx, mid int64, recoverDate time.Time) (err error) {
|
|
if _, err = tx.Exec(_updateMoralRecoverDate, recoverDate, mid); err != nil {
|
|
err = errors.Wrapf(err, "TxUpdateMoralRecoverDate mid(%d) recoverDate(%v)", mid, recoverDate)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// TxInitMoral set user moral.
|
|
func (d *Dao) TxInitMoral(tx *xsql.Tx, mid, moral, added, deducted int64, lastRecoverDate time.Time) (err error) {
|
|
if _, err = tx.Exec(_initMoral, mid, moral, added, deducted, lastRecoverDate); err != nil {
|
|
err = errors.Wrapf(err, "TxInitMoral mid(%d) moral(%v)", mid, moral)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetOfficialDoc add official doc.
|
|
func (d *Dao) SetOfficialDoc(c context.Context, od *model.OfficialDoc) (err error) {
|
|
_, err = d.db.Exec(c, _setOfficialDoc, od.Mid, od.Name, model.OfficialStateWait, od.Role,
|
|
od.Title, od.Desc, od.OfficialExtra.String(), od.SubmitSource, od.SubmitTime)
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "dao add official doc")
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// SetOfficialDocAddit add official doc addit.
|
|
func (d *Dao) SetOfficialDocAddit(c context.Context, mid int64, property, vstring string) error {
|
|
_, err := d.db.Exec(c, _setOfficialDocAddit, mid, property, vstring)
|
|
if err != nil {
|
|
err = errors.Wrapf(err, "dao add official doc addit")
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// OfficialDoc get official doc.
|
|
func (d *Dao) OfficialDoc(c context.Context, mid int64) (*model.OfficialDoc, error) {
|
|
od := new(model.OfficialDoc)
|
|
row := d.db.QueryRow(c, _selOfficialDoc, mid)
|
|
if err := row.Scan(&od.Mid, &od.Name, &od.State, &od.Role, &od.Title, &od.Desc, &od.RejectReason, &od.Extra); err != nil {
|
|
err = errors.Wrapf(err, "official doc")
|
|
return nil, err
|
|
}
|
|
od.ParseExtra()
|
|
return od, nil
|
|
}
|
|
|
|
// Realname
|
|
|
|
// RealnameInfo is.
|
|
func (d *Dao) RealnameInfo(c context.Context, mid int64) (info *model.RealnameInfo, err error) {
|
|
row := d.db.QueryRow(c, _selRealnameInfo, mid)
|
|
info = &model.RealnameInfo{}
|
|
if err = row.Scan(&info.ID, &info.MID, &info.Channel, &info.Realname, &info.Country, &info.CardType, &info.Card, &info.CardMD5, &info.Status, &info.Reason, &info.CTime, &info.MTime); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
info = nil
|
|
return
|
|
}
|
|
err = errors.Wrapf(err, "dao RealnameInfo mid(%d)", mid)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// RealnameInfoByCard is.
|
|
func (d *Dao) RealnameInfoByCard(c context.Context, cardMD5 string) (info *model.RealnameInfo, err error) {
|
|
row := d.db.QueryRow(c, _selRealnameInfoByCard, cardMD5)
|
|
info = &model.RealnameInfo{}
|
|
if err = row.Scan(&info.ID, &info.MID, &info.Channel, &info.Realname, &info.Country, &info.CardType, &info.Card, &info.CardMD5, &info.Status, &info.Reason, &info.CTime, &info.MTime); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
info = nil
|
|
return
|
|
}
|
|
err = errors.Wrapf(err, "dao RealnameInfo cardMD5(%s)", cardMD5)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpsertTxRealnameInfo is.
|
|
func (d *Dao) UpsertTxRealnameInfo(c context.Context, tx *xsql.Tx, info *model.RealnameInfo) (err error) {
|
|
if _, err = tx.Exec(_upsertRealnameInfo, info.MID, info.Channel, info.Realname, info.Country, info.CardType, info.Card, info.CardMD5, info.Status, info.Reason, info.Channel, info.Realname, info.Country, info.CardType, info.Card, info.CardMD5, info.Status, info.Reason); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpdateTxRealnameInfo is.
|
|
func (d *Dao) UpdateTxRealnameInfo(c context.Context, tx *xsql.Tx, mid int64, status model.RealnameApplyStatus, reason string) (err error) {
|
|
if _, err = tx.Exec(_updateRealnameInfo, status, reason, mid); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// RealnameApply realname
|
|
func (d *Dao) RealnameApply(c context.Context, mid int64) (apply *model.RealnameApply, err error) {
|
|
row := d.db.Master().QueryRow(c, _selRealnameApply, mid)
|
|
apply = &model.RealnameApply{}
|
|
if err = row.Scan(&apply.ID, &apply.MID, &apply.Realname, &apply.Country, &apply.CardType, &apply.CardNum, &apply.CardMD5, &apply.HandIMG, &apply.FrontIMG, &apply.BackIMG, &apply.Status, &apply.Operator, &apply.OperatorID, &apply.OperatorTime, &apply.Remark, &apply.RemarkStatus, &apply.CTime, &apply.MTime); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
apply = nil
|
|
return
|
|
}
|
|
err = errors.Wrapf(err, "dao RealnameApply mid(%d)", mid)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// InsertRealnameApply is
|
|
func (d *Dao) InsertRealnameApply(c context.Context, data *model.RealnameApply) (err error) {
|
|
if _, err = d.db.Exec(c, _insertRealnameApply, data.MID, data.Realname, data.Country, data.CardType, data.CardNum, data.CardMD5, data.HandIMG, data.FrontIMG, data.BackIMG, data.Status); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// RealnameApplyIMG is
|
|
func (d *Dao) RealnameApplyIMG(c context.Context, id int) (img *model.RealnameApplyImage, err error) {
|
|
row := d.db.Master().QueryRow(c, _selRealnameApplyImg, id)
|
|
img = &model.RealnameApplyImage{}
|
|
if err = row.Scan(&img.ID, &img.IMGData, &img.CTime, &img.MTime); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
img = nil
|
|
return
|
|
}
|
|
err = errors.Wrapf(err, "dao RealnameApplyIMG mid(%d)", id)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// InsertRealnameApplyImg is
|
|
func (d *Dao) InsertRealnameApplyImg(c context.Context, data *model.RealnameApplyImage) (id int64, err error) {
|
|
var res sql.Result
|
|
if res, err = d.db.Exec(c, _insertRealnameApplyImg, data.IMGData); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
if id, err = res.LastInsertId(); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// InsertOldRealnameApply is
|
|
func (d *Dao) InsertOldRealnameApply(c context.Context, data *model.RealnameApply) (id int64, err error) {
|
|
var (
|
|
res sql.Result
|
|
cardType = int16(data.CardType)
|
|
)
|
|
if data.Country > 0 {
|
|
cardType = data.Country
|
|
}
|
|
if res, err = d.accdb.Exec(c, _insertOldRealnameApply, data.MID, data.Realname, cardType, data.CardNum, data.CardMD5, data.FrontIMG, data.HandIMG, data.BackIMG, data.CTime.Unix(), data.Status); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
if id, err = res.LastInsertId(); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// InsertOldRealnameApplyImg is
|
|
func (d *Dao) InsertOldRealnameApplyImg(c context.Context, data *model.RealnameApplyImage) (id int64, err error) {
|
|
var res sql.Result
|
|
if res, err = d.accdb.Exec(c, _insertOldRealnameApplyImg, data.IMGData, data.CTime); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
if id, err = res.LastInsertId(); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// InsertTxRealnameAlipayApply .
|
|
func (d *Dao) InsertTxRealnameAlipayApply(c context.Context, tx *xsql.Tx, data *model.RealnameAlipayApply) (err error) {
|
|
if _, err = tx.Exec(_insertRealnameAlipayApply, data.MID, data.Realname, data.Card, data.IMG, data.Status, data.Reason, data.Bizno); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpdateTxRealnameAlipayApply is.
|
|
func (d *Dao) UpdateTxRealnameAlipayApply(c context.Context, tx *xsql.Tx, id int64, status model.RealnameApplyStatus, reason string) (err error) {
|
|
if _, err = tx.Exec(_updateRealnameAlipayApply, status, reason, id); err != nil {
|
|
err = errors.WithStack(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// RealnameAlipayApply .
|
|
func (d *Dao) RealnameAlipayApply(c context.Context, mid int64) (apply *model.RealnameAlipayApply, err error) {
|
|
row := d.db.QueryRow(c, _selRealnameAlipayApply, mid)
|
|
apply = &model.RealnameAlipayApply{}
|
|
if err = row.Scan(&apply.ID, &apply.MID, &apply.Realname, &apply.Card, &apply.IMG, &apply.Status, &apply.Reason, &apply.Bizno, &apply.CTime, &apply.MTime); err != nil {
|
|
if err == xsql.ErrNoRows {
|
|
err = nil
|
|
apply = nil
|
|
return
|
|
}
|
|
err = errors.Wrapf(err, "dao RealnameAlipayApply mid(%d)", mid)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func prepareStringArray(in []string) string {
|
|
surrounded := make([]string, 0, len(in))
|
|
for _, s := range in {
|
|
surrounded = append(surrounded, fmt.Sprintf(`'%s'`, s))
|
|
}
|
|
return strings.Join(surrounded, ",")
|
|
}
|
|
|
|
// MidByRealnameCards is
|
|
func (d *Dao) MidByRealnameCards(ctx context.Context, cardMD5s []string) (map[string]int64, error) {
|
|
rows, err := d.db.Query(ctx, fmt.Sprintf(_selRealnameInfoMidByCards, prepareStringArray(cardMD5s)))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
result := make(map[string]int64, len(cardMD5s))
|
|
for rows.Next() {
|
|
mid, cardMD5 := int64(0), ""
|
|
if err := rows.Scan(&mid, &cardMD5); err != nil {
|
|
log.Warn("Failed to scan realname info: %+v", err)
|
|
continue
|
|
}
|
|
result[cardMD5] = mid
|
|
}
|
|
return result, nil
|
|
}
|