443 lines
15 KiB
Go
443 lines
15 KiB
Go
package unicom
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"time"
|
|
|
|
"go-common/app/interface/main/app-wall/conf"
|
|
"go-common/app/interface/main/app-wall/model/unicom"
|
|
"go-common/library/cache/memcache"
|
|
"go-common/library/database/elastic"
|
|
xsql "go-common/library/database/sql"
|
|
"go-common/library/log"
|
|
httpx "go-common/library/net/http/blademaster"
|
|
)
|
|
|
|
const (
|
|
//unicom
|
|
_inOrderSyncSQL = `INSERT IGNORE INTO unicom_order (usermob,cpid,spid,type,ordertime,canceltime,endtime,channelcode,province,area,ordertype,videoid,ctime,mtime)
|
|
VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE cpid=?,spid=?,type=?,ordertime=?,canceltime=?,endtime=?,channelcode=?,province=?,area=?,ordertype=?,videoid=?,mtime=?`
|
|
_inAdvanceSyncSQL = `INSERT IGNORE INTO unicom_order_advance (usermob,userphone,cpid,spid,ordertime,channelcode,province,area,ctime,mtime)
|
|
VALUES(?,?,?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE cpid=?,spid=?,ordertime=?,channelcode=?,province=?,area=?,mtime=?`
|
|
_upOrderFlowSQL = `UPDATE unicom_order SET time=?,flowbyte=?,mtime=? WHERE usermob=?`
|
|
_orderUserSyncSQL = `SELECT usermob,cpid,spid,type,ordertime,canceltime,endtime,channelcode,province,area,ordertype,videoid,time,flowbyte FROM unicom_order WHERE usermob=?
|
|
ORDER BY type DESC`
|
|
_inIPSyncSQL = `INSERT IGNORE INTO unicom_ip (ipbegion,ipend,provinces,isopen,opertime,sign,ctime,mtime) VALUES(?,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE
|
|
ipbegion=?,ipend=?,provinces=?,isopen=?,opertime=?,sign=?,mtime=?`
|
|
_ipSyncSQL = `SELECT ipbegion,ipend FROM unicom_ip WHERE isopen=1`
|
|
//pack
|
|
_inPackSQL = `INSERT IGNORE INTO unicom_pack (usermob,mid) VALUES(?,?)`
|
|
_packSQL = `SELECT usermob,mid FROM unicom_pack WHERE usermob=?`
|
|
// update unicom ip
|
|
_inUnicomIPSyncSQL = `INSERT IGNORE INTO unicom_ip (ipbegion,ipend,isopen,ctime,mtime) VALUES(?,?,?,?,?) ON DUPLICATE KEY UPDATE
|
|
ipbegion=?,ipend=?,isopen=?,mtime=?`
|
|
_upUnicomIPSQL = `UPDATE unicom_ip SET isopen=?,mtime=? WHERE ipbegion=? AND ipend=?`
|
|
// unicom integral change
|
|
_inUserBindSQL = `INSERT IGNORE INTO unicom_user_bind (usermob,phone,mid,state,integral,flow) VALUES(?,?,?,?,?,?) ON DUPLICATE KEY UPDATE
|
|
phone=?,state=?`
|
|
_userBindSQL = `SELECT usermob,phone,mid,state,integral,flow,monthlytime FROM unicom_user_bind WHERE state=1 AND mid=?`
|
|
_userBindPhoneMidSQL = `SELECT mid FROM unicom_user_bind WHERE phone=? AND state=1`
|
|
_upUserIntegralSQL = `UPDATE unicom_user_bind SET integral=?,flow=? WHERE phone=? AND mid=?`
|
|
_userPacksSQL = `SELECT id,ptype,pdesc,amount,capped,integral,param FROM unicom_user_packs WHERE state=1`
|
|
_userPacksByIDSQL = `SELECT id,ptype,pdesc,amount,capped,integral,param,state FROM unicom_user_packs WHERE id=?`
|
|
_upUserPacksSQL = `UPDATE unicom_user_packs SET amount=?,state=? WHERE id=?`
|
|
_inUserPackLogSQL = `INSERT INTO unicom_user_packs_log (phone,usermob,mid,request_no,ptype,integral,pdesc) VALUES (?,?,?,?,?,?,?)`
|
|
_userBindOldSQL = `SELECT usermob,phone,mid,state,integral,flow FROM unicom_user_bind WHERE phone=? ORDER BY mtime DESC limit 1`
|
|
_userPacksLogSQL = `SELECT phone,integral,ptype,pdesc FROM unicom_user_packs_log WHERE mtime>=? AND mtime<?`
|
|
)
|
|
|
|
type Dao struct {
|
|
db *xsql.DB
|
|
client *httpx.Client
|
|
uclient *httpx.Client
|
|
//unicom
|
|
inOrderSyncSQL *xsql.Stmt
|
|
inAdvanceSyncSQL *xsql.Stmt
|
|
upOrderFlowSQL *xsql.Stmt
|
|
orderUserSyncSQL *xsql.Stmt
|
|
inIPSyncSQL *xsql.Stmt
|
|
ipSyncSQL *xsql.Stmt
|
|
// unicom integral change
|
|
inUserBindSQL *xsql.Stmt
|
|
userBindSQL *xsql.Stmt
|
|
userBindPhoneMidSQL *xsql.Stmt
|
|
upUserIntegralSQL *xsql.Stmt
|
|
userPacksSQL *xsql.Stmt
|
|
userPacksByIDSQL *xsql.Stmt
|
|
upUserPacksSQL *xsql.Stmt
|
|
inUserPackLogSQL *xsql.Stmt
|
|
userBindOldSQL *xsql.Stmt
|
|
//pack
|
|
inPackSQL *xsql.Stmt
|
|
packSQL *xsql.Stmt
|
|
// memcache
|
|
mc *memcache.Pool
|
|
expire int32
|
|
flowKeyExpired int32
|
|
flowWait int32
|
|
// unicom url
|
|
unicomIPURL string
|
|
unicomFlowExchangeURL string
|
|
// order url
|
|
orderURL string
|
|
ordercancelURL string
|
|
sendsmscodeURL string
|
|
smsNumberURL string
|
|
// elastic
|
|
es *elastic.Elastic
|
|
}
|
|
|
|
func New(c *conf.Config) (d *Dao) {
|
|
d = &Dao{
|
|
db: xsql.NewMySQL(c.MySQL.Show),
|
|
client: httpx.NewClient(conf.Conf.HTTPBroadband),
|
|
uclient: httpx.NewClient(conf.Conf.HTTPUnicom),
|
|
// unicom url
|
|
unicomIPURL: c.Host.Unicom + _unicomIPURL,
|
|
unicomFlowExchangeURL: c.Host.UnicomFlow + _unicomFlowExchangeURL,
|
|
// memcache
|
|
mc: memcache.NewPool(c.Memcache.Operator.Config),
|
|
expire: int32(time.Duration(c.Memcache.Operator.Expire) / time.Second),
|
|
flowKeyExpired: int32(time.Duration(c.Unicom.KeyExpired) / time.Second),
|
|
flowWait: int32(time.Duration(c.Unicom.FlowWait) / time.Second),
|
|
// order url
|
|
orderURL: c.Host.Broadband + _orderURL,
|
|
ordercancelURL: c.Host.Broadband + _ordercancelURL,
|
|
sendsmscodeURL: c.Host.Broadband + _sendsmscodeURL,
|
|
smsNumberURL: c.Host.Broadband + _smsNumberURL,
|
|
// elastic
|
|
es: elastic.NewElastic(nil),
|
|
}
|
|
d.inOrderSyncSQL = d.db.Prepared(_inOrderSyncSQL)
|
|
d.inAdvanceSyncSQL = d.db.Prepared(_inAdvanceSyncSQL)
|
|
d.upOrderFlowSQL = d.db.Prepared(_upOrderFlowSQL)
|
|
d.orderUserSyncSQL = d.db.Prepared(_orderUserSyncSQL)
|
|
d.inIPSyncSQL = d.db.Prepared(_inIPSyncSQL)
|
|
d.ipSyncSQL = d.db.Prepared(_ipSyncSQL)
|
|
// unicom integral change
|
|
d.inUserBindSQL = d.db.Prepared(_inUserBindSQL)
|
|
d.userBindSQL = d.db.Prepared(_userBindSQL)
|
|
d.userBindPhoneMidSQL = d.db.Prepared(_userBindPhoneMidSQL)
|
|
d.upUserIntegralSQL = d.db.Prepared(_upUserIntegralSQL)
|
|
d.userPacksSQL = d.db.Prepared(_userPacksSQL)
|
|
d.upUserPacksSQL = d.db.Prepared(_upUserPacksSQL)
|
|
d.userPacksByIDSQL = d.db.Prepared(_userPacksByIDSQL)
|
|
d.inUserPackLogSQL = d.db.Prepared(_inUserPackLogSQL)
|
|
d.userBindOldSQL = d.db.Prepared(_userBindOldSQL)
|
|
//pack
|
|
d.inPackSQL = d.db.Prepared(_inPackSQL)
|
|
d.packSQL = d.db.Prepared(_packSQL)
|
|
return
|
|
}
|
|
|
|
// InOrdersSync insert OrdersSync
|
|
func (d *Dao) InOrdersSync(ctx context.Context, usermob string, u *unicom.UnicomJson, now time.Time) (row int64, err error) {
|
|
res, err := d.inOrderSyncSQL.Exec(ctx, usermob,
|
|
u.Cpid, u.Spid, u.TypeInt, u.Ordertime, u.Canceltime, u.Endtime,
|
|
u.Channelcode, u.Province, u.Area, u.Ordertypes, u.Videoid, now, now,
|
|
u.Cpid, u.Spid, u.TypeInt, u.Ordertime, u.Canceltime, u.Endtime,
|
|
u.Channelcode, u.Province, u.Area, u.Ordertypes, u.Videoid, now)
|
|
if err != nil {
|
|
log.Error("d.inOrderSyncSQL.Exec error(%v)", err)
|
|
return
|
|
}
|
|
utmp := &unicom.Unicom{}
|
|
utmp.UnicomJSONTOUincom(usermob, u)
|
|
if err = d.UpdateUnicomCache(ctx, usermob, utmp); err != nil {
|
|
log.Error("d.UpdateUnicomCache usermob(%v) error(%v)", usermob, err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// InAdvanceSync insert AdvanceSync
|
|
func (d *Dao) InAdvanceSync(ctx context.Context, usermob string, u *unicom.UnicomJson, now time.Time) (row int64, err error) {
|
|
res, err := d.inAdvanceSyncSQL.Exec(ctx, usermob, u.Userphone,
|
|
u.Cpid, u.Spid, u.Ordertime, u.Channelcode, u.Province, u.Area, now, now,
|
|
u.Cpid, u.Spid, u.Ordertime, u.Channelcode, u.Province, u.Area, now)
|
|
if err != nil {
|
|
log.Error("d.inAdvanceSyncSQL.Exec error(%v)", err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// FlowSync update OrdersSync
|
|
func (d *Dao) FlowSync(ctx context.Context, flowbyte int, usermob, time string, now time.Time) (row int64, err error) {
|
|
res, err := d.upOrderFlowSQL.Exec(ctx, time, flowbyte, now, usermob)
|
|
if err != nil {
|
|
log.Error("d.upOrderFlowSQL.Exec error(%v)", err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// OrdersUserFlow select user OrdersSync
|
|
func (d *Dao) OrdersUserFlow(ctx context.Context, usermob string) (res []*unicom.Unicom, err error) {
|
|
rows, err := d.orderUserSyncSQL.Query(ctx, usermob)
|
|
if err != nil {
|
|
log.Error("query error (%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
u := &unicom.Unicom{}
|
|
if err = rows.Scan(&u.Usermob, &u.Cpid, &u.Spid, &u.TypeInt, &u.Ordertime, &u.Canceltime, &u.Endtime, &u.Channelcode, &u.Province,
|
|
&u.Area, &u.Ordertypes, &u.Videoid, &u.Time, &u.Flowbyte); err != nil {
|
|
log.Error("OrdersUserFlow row.Scan err (%v)", err)
|
|
return
|
|
}
|
|
u.UnicomChange()
|
|
res = append(res, u)
|
|
}
|
|
return
|
|
}
|
|
|
|
// InIPSync insert IpSync
|
|
func (d *Dao) InIPSync(ctx context.Context, u *unicom.UnicomIpJson, now time.Time) (row int64, err error) {
|
|
res, err := d.inIPSyncSQL.Exec(ctx, u.Ipbegin, u.Ipend, u.Provinces, u.Isopen, u.Opertime, u.Sign, now, now,
|
|
u.Ipbegin, u.Ipend, u.Provinces, u.Isopen, u.Opertime, u.Sign, now)
|
|
if err != nil {
|
|
log.Error("d.inIPSyncSQL.Exec error(%v)", err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// InPack insert Privilege pack
|
|
func (d *Dao) InPack(ctx context.Context, usermob string, mid int64) (row int64, err error) {
|
|
res, err := d.inPackSQL.Exec(ctx, usermob, mid)
|
|
if err != nil {
|
|
log.Error("d.inPackSQL.Exec error(%v)", err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// Pack select Privilege pack
|
|
func (d *Dao) Pack(ctx context.Context, usermobStr string) (res map[string]map[int64]struct{}, err error) {
|
|
row := d.packSQL.QueryRow(ctx, usermobStr)
|
|
var (
|
|
usermob string
|
|
mid int64
|
|
)
|
|
res = map[string]map[int64]struct{}{}
|
|
if err = row.Scan(&usermob, &mid); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("OrdersUserFlow rows.Scan err (%v)", err)
|
|
}
|
|
}
|
|
if user, ok := res[usermob]; !ok {
|
|
res[usermob] = map[int64]struct{}{
|
|
mid: struct{}{},
|
|
}
|
|
} else {
|
|
user[mid] = struct{}{}
|
|
}
|
|
return
|
|
}
|
|
|
|
// IPSync select all ipSync
|
|
func (d *Dao) IPSync(ctx context.Context) (res []*unicom.UnicomIP, err error) {
|
|
rows, err := d.ipSyncSQL.Query(ctx)
|
|
if err != nil {
|
|
log.Error("query error (%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
res = []*unicom.UnicomIP{}
|
|
for rows.Next() {
|
|
u := &unicom.UnicomIP{}
|
|
if err = rows.Scan(&u.Ipbegin, &u.Ipend); err != nil {
|
|
log.Error("rows.Scan error(%v)", err)
|
|
return
|
|
}
|
|
u.UnicomIPChange()
|
|
res = append(res, u)
|
|
}
|
|
return
|
|
}
|
|
|
|
// InUnicomIPSync insert or update unicom_ip
|
|
func (d *Dao) InUnicomIPSync(tx *xsql.Tx, u *unicom.UnicomIP, now time.Time) (row int64, err error) {
|
|
res, err := tx.Exec(_inUnicomIPSyncSQL, u.Ipbegin, u.Ipend, 1, now, now,
|
|
u.Ipbegin, u.Ipend, 1, now)
|
|
if err != nil {
|
|
log.Error("tx.inUnicomIPSyncSQL.Exec error(%v)", err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UpUnicomIP update unicom_ip state
|
|
func (d *Dao) UpUnicomIP(tx *xsql.Tx, ipstart, ipend, state int, now time.Time) (row int64, err error) {
|
|
res, err := tx.Exec(_upUnicomIPSQL, state, now, ipstart, ipend)
|
|
if err != nil {
|
|
log.Error("tx.upUnicomIPSQL.Exec error(%v)", err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// InUserBind unicom insert user bind
|
|
func (d *Dao) InUserBind(ctx context.Context, ub *unicom.UserBind) (row int64, err error) {
|
|
res, err := d.inUserBindSQL.Exec(ctx, ub.Usermob, ub.Phone, ub.Mid, ub.State, ub.Integral, ub.Flow, ub.Phone, ub.State)
|
|
if err != nil {
|
|
log.Error("insert user bind error(%v)", err)
|
|
return
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UserBind unicom select user bind
|
|
func (d *Dao) UserBind(ctx context.Context, mid int64) (res *unicom.UserBind, err error) {
|
|
row := d.userBindSQL.QueryRow(ctx, mid)
|
|
if row == nil {
|
|
log.Error("userBindSQL is null")
|
|
return
|
|
}
|
|
res = &unicom.UserBind{}
|
|
if err = row.Scan(&res.Usermob, &res.Phone, &res.Mid, &res.State, &res.Integral, &res.Flow, &res.Monthly); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("userBindSQL row.Scan error(%v)", err)
|
|
}
|
|
res = nil
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// UserPacks user pack list
|
|
func (d *Dao) UserPacks(ctx context.Context) (res []*unicom.UserPack, err error) {
|
|
rows, err := d.userPacksSQL.Query(ctx)
|
|
if err != nil {
|
|
log.Error("user pack sql error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
u := &unicom.UserPack{}
|
|
if err = rows.Scan(&u.ID, &u.Type, &u.Desc, &u.Amount, &u.Capped, &u.Integral, &u.Param); err != nil {
|
|
log.Error("user pack sql error(%v)", err)
|
|
return
|
|
}
|
|
res = append(res, u)
|
|
}
|
|
return
|
|
}
|
|
|
|
// UserPackByID user pack by id
|
|
func (d *Dao) UserPackByID(ctx context.Context, id int64) (res map[int64]*unicom.UserPack, err error) {
|
|
res = map[int64]*unicom.UserPack{}
|
|
row := d.userPacksByIDSQL.QueryRow(ctx, id)
|
|
if row == nil {
|
|
log.Error("user pack sql is null")
|
|
return
|
|
}
|
|
u := &unicom.UserPack{}
|
|
if err = row.Scan(&u.ID, &u.Type, &u.Desc, &u.Amount, &u.Capped, &u.Integral, &u.Param, &u.State); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("userPacksByIDSQL row.Scan error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
res[id] = u
|
|
return
|
|
}
|
|
|
|
// UpUserPacks update user packs
|
|
func (d *Dao) UpUserPacks(ctx context.Context, u *unicom.UserPack, id int64) (row int64, err error) {
|
|
res, err := d.upUserPacksSQL.Exec(ctx, u.Amount, u.State, id)
|
|
if err != nil {
|
|
log.Error("update user pack sql error(%v)", err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UpUserIntegral update unicom user integral
|
|
func (d *Dao) UpUserIntegral(ctx context.Context, ub *unicom.UserBind) (row int64, err error) {
|
|
res, err := d.upUserIntegralSQL.Exec(ctx, ub.Integral, ub.Flow, ub.Phone, ub.Mid)
|
|
if err != nil {
|
|
log.Error("update user integral sql error(%v)", err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UserBindPhoneMid mid by phone
|
|
func (d *Dao) UserBindPhoneMid(ctx context.Context, phone string) (mid int64, err error) {
|
|
row := d.userBindPhoneMidSQL.QueryRow(ctx, phone)
|
|
if row == nil {
|
|
log.Error("user pack sql is null")
|
|
return
|
|
}
|
|
if err = row.Scan(&mid); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("userPacksByIDSQL row.Scan error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// InUserPackLog insert unicom user pack log
|
|
func (d *Dao) InUserPackLog(ctx context.Context, u *unicom.UserPackLog) (row int64, err error) {
|
|
res, err := d.inUserPackLogSQL.Exec(ctx, u.Phone, u.Usermob, u.Mid, u.RequestNo, u.Type, u.Integral, u.Desc)
|
|
if err != nil {
|
|
log.Error("insert user pack log integral sql error(%v)", err)
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
|
|
// UserBindOld user by phone
|
|
func (d *Dao) UserBindOld(ctx context.Context, phone string) (res *unicom.UserBind, err error) {
|
|
row := d.userBindOldSQL.QueryRow(ctx, phone)
|
|
if row == nil {
|
|
log.Error("user bind old sql is null")
|
|
return
|
|
}
|
|
res = &unicom.UserBind{}
|
|
if err = row.Scan(&res.Usermob, &res.Phone, &res.Mid, &res.State, &res.Integral, &res.Flow); err != nil {
|
|
log.Error("userBindSQL row.Scan error(%v)", err)
|
|
res = nil
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// UserPacksLog user pack logs
|
|
func (d *Dao) UserPacksLog(ctx context.Context, start, end time.Time) (res []*unicom.UserPackLog, err error) {
|
|
rows, err := d.db.Query(ctx, _userPacksLogSQL, start, end)
|
|
if err != nil {
|
|
log.Error("query error (%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
u := &unicom.UserPackLog{}
|
|
if err = rows.Scan(&u.Phone, &u.Integral, &u.Type, &u.UserDesc); err != nil {
|
|
log.Error("user packs log sql error(%v)", err)
|
|
return
|
|
}
|
|
res = append(res, u)
|
|
}
|
|
err = rows.Err()
|
|
return
|
|
}
|
|
|
|
// BeginTran begin a transacition
|
|
func (d *Dao) BeginTran(ctx context.Context) (tx *xsql.Tx, err error) {
|
|
return d.db.Begin(ctx)
|
|
}
|