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.
500 lines
14 KiB
500 lines
14 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"encoding/base64" |
|
"fmt" |
|
"strings" |
|
"time" |
|
|
|
"go-common/app/admin/main/member/model" |
|
"go-common/library/cache/memcache" |
|
"go-common/library/log" |
|
|
|
"github.com/pkg/errors" |
|
) |
|
|
|
var ( |
|
_reasonKey = "reason" |
|
) |
|
|
|
func realnameImageKey(IMGData string) string { |
|
return fmt.Sprintf("realname_image_%s", IMGData) |
|
} |
|
|
|
// RealnameInfo is. |
|
func (d *Dao) RealnameInfo(ctx context.Context, mid int64) (info *model.DBRealnameInfo, err error) { |
|
info = &model.DBRealnameInfo{} |
|
if err = d.memberRead.Table(info.TableName()).Where("mid = ?", mid).First(&info).Error; err != nil { |
|
info = nil |
|
err = errors.WithStack(err) |
|
} |
|
return |
|
} |
|
|
|
// BatchRealnameInfo is |
|
func (d *Dao) BatchRealnameInfo(ctx context.Context, mids []int64) (map[int64]*model.DBRealnameInfo, error) { |
|
find := make([]*model.DBRealnameInfo, 0, len(mids)) |
|
db := d.memberRead.Table("realname_info").Where("mid IN (?)", mids).Where("status=?", model.RealnameApplyStatePassed.DBStatus()).Find(&find) |
|
if err := db.Error; err != nil { |
|
return nil, err |
|
} |
|
result := make(map[int64]*model.DBRealnameInfo, len(find)) |
|
for _, ri := range find { |
|
result[ri.MID] = ri |
|
} |
|
return result, nil |
|
} |
|
|
|
// RealnameInfoByCardMD5 is. |
|
func (d *Dao) RealnameInfoByCardMD5(ctx context.Context, cardMD5 string, state int, channel uint8) (infos []*model.DBRealnameInfo, err error) { |
|
infos = make([]*model.DBRealnameInfo, 0) |
|
var info *model.DBRealnameInfo |
|
db := d.memberRead.Table(info.TableName()).Where("card_md5 = ?", cardMD5).Where("channel = ?", channel) |
|
if state >= 0 { |
|
db = db.Where("status = ?", state) |
|
} |
|
|
|
if err = db.Find(&infos).Error; err != nil { |
|
if !db.RecordNotFound() { |
|
err = errors.Wrapf(err, "RealnameInfoByCardMD5") |
|
return |
|
} |
|
err = nil |
|
return |
|
} |
|
return |
|
} |
|
|
|
// UpdateRealnameAlipayApply is. |
|
func (d *Dao) UpdateRealnameAlipayApply(ctx context.Context, id int64, adminID int64, adminName string, state int, reason string) (err error) { |
|
var ( |
|
mld *model.DBRealnameAlipayApply |
|
ups = map[string]interface{}{ |
|
"operator": adminName, |
|
"operator_id": adminID, |
|
"operator_time": time.Now(), |
|
"status": state, |
|
"reason": reason, |
|
} |
|
) |
|
if err = d.member.Table(mld.TableName()).Where("id = ?", id).Updates(ups).Error; err != nil { |
|
err = errors.Wrapf(err, "UpdateRealnameAlipayApply") |
|
} |
|
return |
|
} |
|
|
|
// UpdateRealnameInfo is. |
|
func (d *Dao) UpdateRealnameInfo(ctx context.Context, mid int64, state int, reason string) (err error) { |
|
var ( |
|
mld *model.DBRealnameInfo |
|
ups = map[string]interface{}{ |
|
"status": state, |
|
"reason": reason, |
|
} |
|
) |
|
if err = d.member.Table(mld.TableName()).Where("mid = ?", mid).Updates(ups).Error; err != nil { |
|
err = errors.Wrapf(err, "UpdateRealnameInfo") |
|
} |
|
return |
|
} |
|
|
|
// RealnameMainApply is. |
|
func (d *Dao) RealnameMainApply(ctx context.Context, id int64) (apply *model.DBRealnameApply, err error) { |
|
apply = &model.DBRealnameApply{ |
|
Status: model.RealnameApplyStateNone.DBStatus(), |
|
} |
|
if err = d.memberRead.Table(apply.TableName()).Where("id = ?", id).First(&apply).Error; err != nil { |
|
err = errors.WithStack(err) |
|
} |
|
return |
|
} |
|
|
|
// RealnameAlipayApply is. |
|
func (d *Dao) RealnameAlipayApply(ctx context.Context, id int64) (apply *model.DBRealnameAlipayApply, err error) { |
|
apply = &model.DBRealnameAlipayApply{ |
|
Status: model.RealnameApplyStateNone.DBStatus(), |
|
} |
|
if err = d.memberRead.Table(apply.TableName()).Where("id = ?", id).First(&apply).Error; err != nil { |
|
err = errors.WithStack(err) |
|
} |
|
return |
|
} |
|
|
|
// RealnameMainList is. |
|
func (d *Dao) RealnameMainList(ctx context.Context, mids []int64, cardType int, country int, opName string, tsFrom, tsTo int64, state int, pn, ps int, isDesc bool) (list []*model.DBRealnameApply, total int, err error) { |
|
var ( |
|
mdl *model.DBRealnameApply |
|
) |
|
db := d.memberRead.Table(mdl.TableName()) |
|
if state >= 0 { |
|
db = db.Where("status = ?", state) |
|
} |
|
if len(mids) > 0 { |
|
db = db.Where("mid in (?)", mids) |
|
} |
|
if cardType >= 0 { |
|
db = db.Where("card_type = ?", cardType) |
|
} |
|
if country >= 0 { |
|
db = db.Where("country = ?", country) |
|
} |
|
if opName != "" { |
|
db = db.Where("operator = ?", opName) |
|
} |
|
if tsTo > 0 { |
|
timeTo := time.Unix(tsTo, 0) |
|
db = db.Where("mtime <= ?", timeTo) |
|
} |
|
if tsFrom > 0 { |
|
timeFrom := time.Unix(tsFrom, 0) |
|
db = db.Where("mtime >= ?", timeFrom) |
|
} |
|
if err = db.Count(&total).Error; err != nil { |
|
err = errors.Wrapf(err, "realname apply list count") |
|
return |
|
} |
|
mtimeSort := "mtime ASC" |
|
if isDesc { |
|
mtimeSort = "mtime DESC" |
|
} |
|
|
|
db = db.Order(mtimeSort).Offset((pn - 1) * ps).Limit(ps) |
|
if err = db.Find(&list).Error; err != nil { |
|
if !db.RecordNotFound() { |
|
err = errors.Wrapf(err, "realname apply list") |
|
return |
|
} |
|
err = nil |
|
return |
|
} |
|
return |
|
} |
|
|
|
// RealnameAlipayList is. |
|
func (d *Dao) RealnameAlipayList(ctx context.Context, mids []int64, tsFrom, tsTo int64, state int, pn, ps int, isDesc bool) (list []*model.DBRealnameAlipayApply, total int, err error) { |
|
var ( |
|
mdl *model.DBRealnameAlipayApply |
|
) |
|
db := d.memberRead.Table(mdl.TableName()) |
|
if state >= 0 { |
|
db = db.Where("status = ?", state) |
|
} |
|
if len(mids) > 0 { |
|
db = db.Where("mid in (?)", mids) |
|
} |
|
if tsTo > 0 { |
|
timeTo := time.Unix(tsTo, 0) |
|
db = db.Where("mtime <= ?", timeTo) |
|
} |
|
if tsFrom > 0 { |
|
timeFrom := time.Unix(tsFrom, 0) |
|
db = db.Where("mtime >= ?", timeFrom) |
|
} |
|
if err = db.Count(&total).Error; err != nil { |
|
err = errors.Wrapf(err, "realname apply list count") |
|
return |
|
} |
|
mtimeSort := "mtime ASC" |
|
if isDesc { |
|
mtimeSort = "mtime DESC" |
|
} |
|
|
|
db = db.Order(mtimeSort).Offset((pn - 1) * ps).Limit(ps) |
|
|
|
if err = db.Find(&list).Error; err != nil { |
|
if !db.RecordNotFound() { |
|
err = errors.Wrapf(err, "realname apply list") |
|
return |
|
} |
|
err = nil |
|
return |
|
} |
|
return |
|
} |
|
|
|
// RealnameSearchCards is. |
|
func (d *Dao) RealnameSearchCards(ctx context.Context, cardMD5s []string) (list []*model.DBRealnameInfo, err error) { |
|
var ( |
|
mdl *model.DBRealnameInfo |
|
) |
|
db := d.memberRead.Table(mdl.TableName()).Where("card_md5 in (?)", cardMD5s) |
|
if err = db.Find(&list).Error; err != nil { |
|
if !db.RecordNotFound() { |
|
err = errors.Wrapf(err, "realname apply list") |
|
return |
|
} |
|
err = nil |
|
return |
|
} |
|
return |
|
} |
|
|
|
// UpdateRealnameMainApply . |
|
func (d *Dao) UpdateRealnameMainApply(ctx context.Context, id int, state int, opname string, opid int64, optime time.Time, remark string) (err error) { |
|
var ( |
|
mld *model.DBRealnameApply |
|
ups = map[string]interface{}{ |
|
"operator": opname, |
|
"operator_id": opid, |
|
"operator_time": optime, |
|
"remark": remark, |
|
"remark_status": 1, |
|
"status": state, |
|
} |
|
) |
|
if err = d.member.Table(mld.TableName()).Where("id = ?", id).Updates(ups).Error; err != nil { |
|
err = errors.Wrapf(err, "UpdateRealnameApply") |
|
} |
|
return |
|
} |
|
|
|
// UpdateOldRealnameApply . |
|
func (d *Dao) UpdateOldRealnameApply(ctx context.Context, id int64, state int, opname string, opid int64, optime time.Time, remark string) (err error) { |
|
var ( |
|
ups = map[string]interface{}{ |
|
"operater": opname, |
|
// "operator_id": opid, |
|
"operater_time": optime.Unix(), |
|
"remark": remark, |
|
"remark_status": 1, |
|
"status": state, |
|
} |
|
) |
|
if err = d.account.Table("dede_identification_card_apply").Where("id = ?", id).Updates(ups).Error; err != nil { |
|
err = errors.Wrapf(err, "UpdateOldRealnameApply") |
|
} |
|
return |
|
} |
|
|
|
// RealnameApplyIMG . |
|
func (d *Dao) RealnameApplyIMG(ctx context.Context, ids []int64) (imgMap map[int64]*model.DBRealnameApplyIMG, err error) { |
|
var ( |
|
db = d.memberRead.Where("id in (?)", ids) |
|
list []*model.DBRealnameApplyIMG |
|
) |
|
imgMap = make(map[int64]*model.DBRealnameApplyIMG) |
|
if err = db.Find(&list).Error; err != nil { |
|
if !db.RecordNotFound() { |
|
err = errors.Wrapf(err, "RealnameApplyIMG") |
|
return |
|
} |
|
err = nil |
|
} |
|
for _, l := range list { |
|
imgMap[l.ID] = l |
|
} |
|
return |
|
} |
|
|
|
// RealnameApplyCount . |
|
func (d *Dao) RealnameApplyCount(ctx context.Context, mid int64) (count int, err error) { |
|
var ( |
|
ml *model.DBRealnameApply |
|
aml *model.DBRealnameAlipayApply |
|
tempCount int |
|
db = d.memberRead.Table(ml.TableName()).Where("mid = ?", mid) |
|
db2 = d.memberRead.Table(aml.TableName()).Where("mid = ?", mid) |
|
) |
|
if err = db.Count(&tempCount).Error; err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
count += tempCount |
|
if err = db2.Count(&tempCount).Error; err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
count += tempCount |
|
return |
|
} |
|
|
|
// RealnameReasonList . |
|
func (d *Dao) RealnameReasonList(ctx context.Context) (list []string, total int, err error) { |
|
var ( |
|
conf = &model.DBRealnameConfig{} |
|
db = d.memberRead.Where("`key` = ?", _reasonKey).First(&conf) |
|
) |
|
if err = db.Error; err != nil { |
|
if !db.RecordNotFound() { |
|
err = errors.Wrapf(err, "RealnameReasonList") |
|
return |
|
} |
|
err = nil |
|
} |
|
list = decodeReason(conf.Data) |
|
total = len(list) |
|
return |
|
} |
|
|
|
// UpdateRealnameReason . |
|
func (d *Dao) UpdateRealnameReason(ctx context.Context, list []string) (err error) { |
|
var ( |
|
conf *model.DBRealnameConfig |
|
ups = map[string]interface{}{ |
|
"data": encodeReason(list), |
|
} |
|
) |
|
if err = d.member.Table(conf.TableName()).Where("`key` = ?", _reasonKey).Updates(ups).Error; err != nil { |
|
err = errors.Wrapf(err, "UpdateRealnameReason") |
|
} |
|
return |
|
} |
|
|
|
func encodeReason(list []string) (data string) { |
|
raw := []byte(strings.Join(list, "(#=_=#)")) |
|
return base64.StdEncoding.EncodeToString(raw) |
|
} |
|
|
|
func decodeReason(data string) (list []string) { |
|
var ( |
|
raw []byte |
|
err error |
|
) |
|
if raw, err = base64.StdEncoding.DecodeString(data); err != nil { |
|
err = errors.WithStack(err) |
|
log.Error("%+v", err) |
|
return |
|
} |
|
list = strings.Split(string(raw), "(#=_=#)") |
|
return |
|
} |
|
|
|
// AddRealnameIMG is |
|
func (d *Dao) AddRealnameIMG(ctx context.Context, img *model.DBRealnameApplyIMG) error { |
|
if err := d.member.Create(img).Error; err != nil { |
|
return errors.WithStack(err) |
|
} |
|
return nil |
|
} |
|
|
|
// AddRealnameApply is |
|
func (d *Dao) AddRealnameApply(ctx context.Context, apply *model.DBRealnameApply) error { |
|
if err := d.member.Create(apply).Error; err != nil { |
|
return errors.WithStack(err) |
|
} |
|
return nil |
|
} |
|
|
|
// SubmitRealnameInfo is |
|
func (d *Dao) SubmitRealnameInfo(ctx context.Context, info *model.DBRealnameInfo) error { |
|
ups := map[string]interface{}{ |
|
"channel": info.Channel, |
|
"realname": info.Realname, |
|
"country": info.Country, |
|
"card_type": info.CardType, |
|
"card": info.Card, |
|
"card_md5": info.CardMD5, |
|
"status": info.Status, |
|
"reason": info.Reason, |
|
} |
|
if err := d.member.Table(info.TableName()).Where("mid=?", info.MID).Assign(ups).FirstOrCreate(info).Error; err != nil { |
|
return errors.WithStack(err) |
|
} |
|
return nil |
|
} |
|
|
|
// GetRealnameImageCache is |
|
func (d *Dao) GetRealnameImageCache(ctx context.Context, IMGData string) ([]byte, error) { |
|
key := realnameImageKey(IMGData) |
|
conn := d.memcache.Get(ctx) |
|
defer conn.Close() |
|
item, err := conn.Get(key) |
|
if err != nil { |
|
return nil, err |
|
} |
|
out := []byte{} |
|
if err := conn.Scan(item, &out); err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
// SetRealnameImageCache is |
|
func (d *Dao) SetRealnameImageCache(ctx context.Context, IMGData string, data []byte) error { |
|
key := realnameImageKey(IMGData) |
|
conn := d.memcache.Get(ctx) |
|
defer conn.Close() |
|
return conn.Set(&memcache.Item{ |
|
Key: key, |
|
Value: data, |
|
Flags: memcache.FlagRAW | memcache.FlagGzip, |
|
Expiration: 6 * 3600, // cache for 6 hours |
|
}) |
|
} |
|
|
|
// RecentRealnameApplyImg is |
|
func (d *Dao) RecentRealnameApplyImg(ctx context.Context, duration time.Duration) ([]*model.DBRealnameApplyIMG, error) { |
|
from := time.Now().Add(-duration) |
|
result := []*model.DBRealnameApplyIMG{} |
|
db := d.memberRead.Where("mtime>=?", from).Order("id desc").Find(&result) |
|
if err := db.Error; err != nil { |
|
return nil, err |
|
} |
|
return result, nil |
|
} |
|
|
|
// RejectRealnameMainApply is |
|
func (d *Dao) RejectRealnameMainApply(ctx context.Context, mid int64, opname string, opid int64, remark string) (err error) { |
|
var ( |
|
mld *model.DBRealnameApply |
|
ups = map[string]interface{}{ |
|
"operator": opname, |
|
"operator_id": opid, |
|
"operator_time": time.Now(), |
|
"remark": remark, |
|
"remark_status": 1, |
|
"status": model.RealnameApplyStateRejective.DBStatus(), |
|
} |
|
) |
|
if err = d.member.Table(mld.TableName()). |
|
Where("mid = ?", mid). |
|
Where("status = ?", model.RealnameApplyStatePassed.DBStatus()). |
|
Updates(ups).Error; err != nil { |
|
err = errors.Wrapf(err, "RejectRealnameMainApply") |
|
} |
|
return |
|
} |
|
|
|
// RejectRealnameAlipayApply is |
|
func (d *Dao) RejectRealnameAlipayApply(ctx context.Context, mid int64, opname string, opid int64, reason string) (err error) { |
|
var ( |
|
mld *model.DBRealnameAlipayApply |
|
ups = map[string]interface{}{ |
|
"operator": opname, |
|
"operator_id": opid, |
|
"operator_time": time.Now(), |
|
"status": model.RealnameApplyStateRejective.DBStatus(), |
|
"reason": reason, |
|
} |
|
) |
|
if err = d.member.Table(mld.TableName()). |
|
Where("mid = ?", mid). |
|
Where("status = ?", model.RealnameApplyStatePassed.DBStatus()). |
|
Updates(ups).Error; err != nil { |
|
err = errors.Wrapf(err, "UpdateRealnameAlipayApply") |
|
} |
|
return |
|
} |
|
|
|
// LastPassedRealnameMainApply is |
|
func (d *Dao) LastPassedRealnameMainApply(ctx context.Context, mid int64) (*model.DBRealnameApply, error) { |
|
apply := &model.DBRealnameApply{} |
|
if err := d.member.Table("realname_apply").Where("mid=?", mid). |
|
Where("status=?", model.RealnameApplyStatePassed.DBStatus()). |
|
Order("id DESC").Limit(1).Last(apply).Error; err != nil { |
|
return nil, err |
|
} |
|
return apply, nil |
|
} |
|
|
|
// LastPassedRealnameAlipayApply is |
|
func (d *Dao) LastPassedRealnameAlipayApply(ctx context.Context, mid int64) (*model.DBRealnameAlipayApply, error) { |
|
apply := &model.DBRealnameAlipayApply{} |
|
if err := d.member.Table("realname_alipay_apply").Where("mid=?", mid). |
|
Where("status=?", model.RealnameApplyStatePassed.DBStatus()). |
|
Order("id DESC").Limit(1).Last(apply).Error; err != nil { |
|
return nil, err |
|
} |
|
return apply, nil |
|
}
|
|
|