You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
544 lines
20 KiB
544 lines
20 KiB
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 |
|
}
|
|
|