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.
689 lines
26 KiB
689 lines
26 KiB
package up |
|
|
|
import ( |
|
"context" |
|
"database/sql" |
|
"fmt" |
|
"strconv" |
|
"strings" |
|
"time" |
|
|
|
"github.com/pkg/errors" |
|
|
|
"go-common/app/admin/main/mcn/model" |
|
xsql "go-common/library/database/sql" |
|
"go-common/library/xstr" |
|
) |
|
|
|
const ( |
|
_inMCNRenewalSQL = `INSERT INTO mcn_sign(mcn_mid,company_name,company_license_id,company_license_link, |
|
contract_link,contact_name,contact_title,contact_idcard,contact_phone,begin_date,end_date,state,permission) VALUES (?,?,?,?,?,?,?,?,?,?,?,15,?)` |
|
_inMCNPaySQL = "INSERT INTO mcn_sign_pay(mcn_mid,sign_id,due_date,pay_value) VALUES %s" |
|
_inMCNUPsSQL = "INSERT INTO mcn_up(sign_id,mcn_mid,up_mid,begin_date,end_date,contract_link,up_auth_link,state,state_change_time,up_type,site_link,confirm_time,permission,publication_price) VALUES %s" |
|
|
|
_upMCNStateSQL = "UPDATE mcn_sign SET state=? WHERE id=? AND mcn_mid=?" |
|
_upMCNPaySQL = "UPDATE mcn_sign_pay SET due_date=?,pay_value=? WHERE id=? AND mcn_mid=? AND sign_id=?" |
|
_upMCNPayStateSQL = "UPDATE mcn_sign_pay SET state=? WHERE id=? AND mcn_mid=? AND sign_id=?" |
|
// _upMCNSignRenewaIDSQL = "UPDATE mcn_sign SET renewal_id=? WHERE id=?" |
|
_upMCNUPStateSQL = "UPDATE mcn_up SET state=?,state_change_time=? WHERE id =? AND sign_id=? AND mcn_mid=? AND up_mid=?" |
|
_upMCNImportUPSQL = "UPDATE mcn_data_import_up SET is_reward=1 WHERE sign_id=? AND up_mid=?" |
|
_upMCNPermissionSQL = "UPDATE mcn_sign SET permission = ? WHERE id=?" |
|
_selMCNListSQL = `SELECT s.id, s.mcn_mid,s.state,s.begin_date,s.end_date,s.permission,ifnull(ds.up_count,0),ifnull(ds.fans_count_accumulate,0), |
|
ifnull(ds.fans_count_online_accumulate,0),ifnull(ds.fans_count_real_accumulate,0),ifnull(ds.fans_count_cheat_accumulate,0),ifnull(ds.generate_date,0) |
|
FROM (SELECT * FROM mcn_data_summary WHERE generate_date=(SELECT MAX(generate_date) FROM mcn_data_summary a WHERE a.sign_id=mcn_data_summary.sign_id) AND active_tid=? AND data_type=1) AS ds |
|
RIGHT JOIN mcn_sign s ON s.id=ds.sign_id WHERE ` |
|
_countMCNListSQL = `SELECT COUNT(*) FROM (SELECT * FROM mcn_data_summary WHERE generate_date=(SELECT MAX(generate_date) FROM mcn_data_summary a |
|
WHERE a.sign_id=mcn_data_summary.sign_id) AND active_tid=? AND data_type=1) AS ds RIGHT JOIN mcn_sign s ON s.id=ds.sign_id WHERE %s` |
|
_selMCNPayInfosByID = "SELECT id,mcn_mid,sign_id,due_date,pay_value,state FROM mcn_sign_pay WHERE id=?" |
|
_selMCNPayInfosBySignIDsSQL = "SELECT id,mcn_mid,sign_id,due_date,pay_value,state FROM mcn_sign_pay WHERE sign_id in(%s) ORDER BY due_date ASC" |
|
_selMCNRenewalUPsSQL = "SELECT sign_id,mcn_mid,up_mid,begin_date,end_date,contract_link,up_auth_link,reject_reason,reject_time,state,state_change_time,up_type,site_link,confirm_time,permission,publication_price FROM mcn_up WHERE sign_id=? AND mcn_mid=? AND state IN(10,11,15)" |
|
_selMCNInfoSQL = `SELECT s.id,s.mcn_mid,s.company_name,s.company_license_id,s.company_license_link,s.contract_link,s.contact_name,s.contact_title,s.contact_idcard,s.contact_phone, |
|
s.begin_date,s.end_date,ifnull(s.state,0),ifnull(ds.up_count,0),ifnull(ds.fans_count_accumulate,0),ifnull(ds.archive_count_accumulate,0),ifnull(ds.play_count_accumulate,0), |
|
ifnull(ds.fans_count_cheat_accumulate,0),ifnull(ds.fans_count_real_accumulate,0),ifnull(ds.fans_count_online_accumulate,0) |
|
FROM mcn_sign s LEFT JOIN mcn_data_summary ds ON s.id=ds.sign_id AND ds.active_tid=? AND ds.data_type=1 WHERE s.id = ? ORDER BY ds.generate_date DESC LIMIT 1` |
|
_selMCNUPListSQL = `SELECT u.id,u.sign_id,u.mcn_mid,u.up_mid,u.publication_price,u.permission,ifnull(du.active_tid,0),ifnull(du.fans_count,0),ifnull(du.fans_count_active,0),u.begin_date,u.end_date,u.state, |
|
ifnull(du.fans_increase_accumulate,0),ifnull(du.archive_count,0),ifnull(du.play_count,0),u.contract_link,u.up_auth_link,u.up_type, ifnull(u.site_link, "") |
|
FROM (SELECT * FROM mcn_data_up WHERE generate_date=(SELECT MAX(generate_date) FROM mcn_data_up a WHERE a.up_mid=mcn_data_up.up_mid)) du |
|
RIGHT JOIN mcn_up u ON u.sign_id=du.sign_id AND u.up_mid=du.up_mid AND du.data_type=? WHERE u.state IN(10,11,12,14,15) AND ` |
|
_countMCNUPListSQL = `SELECT COUNT(*) FROM (SELECT * FROM mcn_data_up WHERE generate_date=(SELECT MAX(generate_date) FROM mcn_data_up a WHERE a.up_mid=mcn_data_up.up_mid)) du |
|
RIGHT JOIN mcn_up u ON u.sign_id=du.sign_id AND u.up_mid=du.up_mid AND du.data_type=? WHERE u.state IN(10,11,12,14,15) AND %s` |
|
_selMCNByMCNMIDSQL = `SELECT id,mcn_mid,company_name,company_license_id,company_license_link,contract_link,contact_name, |
|
contact_title,contact_idcard,contact_phone,begin_date,end_date,reject_reason,reject_time,state,ctime,mtime FROM mcn_sign WHERE state IN(10,11,15) AND mcn_mid = ? ORDER BY begin_date DESC LIMIT 1` |
|
_selMCNCheatListSQL = `SELECT fans_count_accumulate,fans_count_cheat_accumulate,mcn_mid,sign_id,up_mid,fans_count_cheat_increase_day,fans_count_cheat_cleaned_accumulate FROM mcn_data_up_cheat WHERE ` |
|
_countMCNCheatListSQL = "SELECT COUNT(*) FROM mcn_data_up_cheat WHERE %s" |
|
_selMCNCheatUPListSQL = `SELECT sign_id,generate_date,fans_count_accumulate,fans_count_cheat_accumulate,mcn_mid,fans_count_cheat_increase_day,fans_count_cheat_cleaned_accumulate FROM mcn_data_up_cheat WHERE up_mid=? ORDER BY generate_date DESC LIMIT ?,?` |
|
_countMCNCheatUPListSQL = "SELECT COUNT(*) FROM mcn_data_up_cheat WHERE up_mid=?" |
|
_selMCNImportUPInfoSQL = "SELECT id,mcn_mid,sign_id,up_mid,standard_fans_date,standard_archive_count,standard_fans_count,is_reward FROM mcn_data_import_up WHERE sign_id=? AND up_mid=? AND standard_fans_type=1" |
|
_selMCNDataSummaryListSQL = `SELECT id,sign_id,data_type,active_tid,generate_date,up_count,fans_count_online_accumulate,fans_count_real_accumulate,fans_count_cheat_accumulate,fans_count_increase_day,archive_count_accumulate,archive_count_day, |
|
play_count_accumulate,play_count_increase_day,fans_count_accumulate FROM mcn_data_summary WHERE ` |
|
_countMCNDataSummaryListSQL = "SELECT COUNT(*) FROM mcn_data_summary WHERE %s" |
|
) |
|
|
|
// TxAddMCNRenewal . |
|
func (d *Dao) TxAddMCNRenewal(tx *xsql.Tx, arg *model.MCNSign) (lastID int64, err error) { |
|
var res sql.Result |
|
if res, err = tx.Exec(_inMCNRenewalSQL, arg.MCNMID, arg.CompanyName, arg.CompanyLicenseID, arg.CompanyLicenseLink, arg.ContractLink, arg.ContactName, arg.ContactTitle, arg.ContactIdcard, arg.ContactPhone, arg.BeginDate, arg.EndDate, arg.Permission); err != nil { |
|
return lastID, err |
|
} |
|
if lastID, err = res.LastInsertId(); err != nil { |
|
return lastID, errors.Errorf("TxAddMCNRenewal res.LastInsertId(%+v) error(%+v)", arg, err) |
|
} |
|
return lastID, nil |
|
} |
|
|
|
// TxAddMCNPays . |
|
func (d *Dao) TxAddMCNPays(tx *xsql.Tx, lastID, mcnMID int64, arg []*model.SignPayReq) (err error) { |
|
l := len(arg) |
|
valueStrings := make([]string, 0, l) |
|
valueArgs := make([]interface{}, 0, l*5) |
|
for _, v := range arg { |
|
valueStrings = append(valueStrings, "(?,?,?,?)") |
|
valueArgs = append(valueArgs, strconv.FormatInt(mcnMID, 10)) |
|
valueArgs = append(valueArgs, strconv.FormatInt(lastID, 10)) |
|
valueArgs = append(valueArgs, v.DueDate) |
|
valueArgs = append(valueArgs, strconv.FormatInt(v.PayValue, 10)) |
|
} |
|
stmt := fmt.Sprintf(_inMCNPaySQL, strings.Join(valueStrings, ",")) |
|
_, err = tx.Exec(stmt, valueArgs...) |
|
return |
|
} |
|
|
|
// TxAddMCNUPs . |
|
func (d *Dao) TxAddMCNUPs(tx *xsql.Tx, signID, mcnMID int64, arg []*model.MCNUP) (err error) { |
|
l := len(arg) |
|
valueStrings := make([]string, 0, l) |
|
valueArgs := make([]interface{}, 0, l*15) |
|
for _, v := range arg { |
|
valueStrings = append(valueStrings, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?)") |
|
valueArgs = append(valueArgs, strconv.FormatInt(signID, 10)) |
|
valueArgs = append(valueArgs, strconv.FormatInt(mcnMID, 10)) |
|
valueArgs = append(valueArgs, strconv.FormatInt(v.UPMID, 10)) |
|
valueArgs = append(valueArgs, v.BeginDate.Time().Format(model.TimeFormatDay)) |
|
valueArgs = append(valueArgs, v.EndDate.Time().Format(model.TimeFormatDay)) |
|
valueArgs = append(valueArgs, v.ContractLink) |
|
valueArgs = append(valueArgs, v.UPAuthLink) |
|
valueArgs = append(valueArgs, strconv.FormatInt(int64(v.State), 10)) |
|
valueArgs = append(valueArgs, v.StateChangeTime.Time().Format(model.TimeFormatSec)) |
|
valueArgs = append(valueArgs, strconv.FormatInt(int64(v.UpType), 10)) |
|
valueArgs = append(valueArgs, v.SiteLink) |
|
valueArgs = append(valueArgs, v.ConfirmTime.Time().Format(model.TimeFormatSec)) |
|
valueArgs = append(valueArgs, strconv.FormatInt(int64(v.Permission), 10)) |
|
valueArgs = append(valueArgs, strconv.FormatInt(int64(v.PublicationPrice), 10)) |
|
} |
|
stmt := fmt.Sprintf(_inMCNUPsSQL, strings.Join(valueStrings, ",")) |
|
_, err = tx.Exec(stmt, valueArgs...) |
|
return |
|
} |
|
|
|
// // TxUpMCNSignRenewaID . |
|
// func (d *Dao) TxUpMCNSignRenewaID(tx *xsql.Tx, signID, renewalID int64) (rows int64, err error) { |
|
// var res sql.Result |
|
// if res, err = tx.Exec(_upMCNSignRenewaIDSQL, renewalID, signID); err != nil { |
|
// return rows, err |
|
// } |
|
// return res.RowsAffected() |
|
// } |
|
|
|
// UpMCNState . |
|
func (d *Dao) UpMCNState(c context.Context, arg *model.MCNStateEditReq) (rows int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _upMCNStateSQL, arg.State, arg.ID, arg.MCNMID); err != nil { |
|
return rows, err |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
// UpMCNPay update mcn_sign_pay. |
|
func (d *Dao) UpMCNPay(c context.Context, arg *model.MCNPayEditReq) (rows int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _upMCNPaySQL, arg.DueDate, arg.PayValue, arg.ID, arg.MCNMID, arg.SignID); err != nil { |
|
return rows, err |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
// UpMCNPayState update mcn_sign_pay state. |
|
func (d *Dao) UpMCNPayState(c context.Context, arg *model.MCNPayStateEditReq) (rows int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _upMCNPayStateSQL, arg.State, arg.ID, arg.MCNMID, arg.SignID); err != nil { |
|
return rows, err |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
// UpMCNImportUPRewardSign . |
|
func (d *Dao) UpMCNImportUPRewardSign(c context.Context, arg *model.MCNImportUPRewardSignReq) (rows int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _upMCNImportUPSQL, arg.SignID, arg.UPMID); err != nil { |
|
return rows, err |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
// UpMCNPermission . |
|
func (d *Dao) UpMCNPermission(c context.Context, signID int64, permission uint32) (rows int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _upMCNPermissionSQL, permission, signID); err != nil { |
|
return rows, err |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
// MCNList . |
|
func (d *Dao) MCNList(c context.Context, arg *model.MCNListReq) (res []*model.MCNListOne, ids, mids []int64, err error) { |
|
sql, values := d.buildMCNListSQL("list", arg) |
|
rows, err := d.db.Query(c, sql, values...) |
|
if err != nil { |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
m := &model.MCNListOne{} |
|
err = rows.Scan(&m.ID, &m.MCNMID, &m.State, &m.BeginDate, &m.EndDate, &m.Permission, &m.UPCount, &m.FansCountAccumulate, &m.FansCountOnlineAccumulate, &m.FansCountRealAccumulate, &m.FansCountCheatAccumulate, &m.GenerateDate) |
|
if err != nil { |
|
return |
|
} |
|
res = append(res, m) |
|
ids = append(ids, m.ID) |
|
mids = append(mids, m.MCNMID) |
|
} |
|
return |
|
} |
|
|
|
// buildMCNListSQL build a MCNList sql string. |
|
func (d *Dao) buildMCNListSQL(SQLType string, arg *model.MCNListReq) (sql string, values []interface{}) { |
|
values = make([]interface{}, 0, 11) |
|
var ( |
|
cond []string |
|
condStr string |
|
curTime = time.Now() |
|
date = time.Date(curTime.Year(), curTime.Month(), curTime.Day(), 0, 0, 0, 0, time.Local) |
|
orderSign = false |
|
) |
|
// defualt where |
|
cond = append(cond, "s.state IN(10,11,12,13,14,15)") |
|
values = append(values, model.AllActiveTid) |
|
if arg.ExpirePay { |
|
cond = append(cond, "s.pay_expire_state = ?") |
|
values = append(values, model.MCNStatePayed) |
|
} |
|
if arg.ExpireSign { |
|
cond = append(cond, "s.end_date <= ? AND s.state = 10") |
|
values = append(values, date.AddDate(0, 0, 30)) |
|
} |
|
if arg.FansNumMin != 0 { |
|
cond = append(cond, "ds.fans_count_accumulate >= ?") |
|
values = append(values, arg.FansNumMin) |
|
} |
|
if arg.FansNumMax != 0 && arg.FansNumMax >= arg.FansNumMin { |
|
cond = append(cond, "ds.fans_count_accumulate <= ?") |
|
values = append(values, arg.FansNumMax) |
|
} |
|
if arg.MCNMID != 0 { |
|
cond = append(cond, "s.mcn_mid=?") |
|
values = append(values, arg.MCNMID) |
|
} |
|
if arg.State != -1 { |
|
cond = append(cond, "s.state=?") |
|
values = append(values, arg.State) |
|
} |
|
var permission = arg.GetAttrPermitVal() |
|
if permission != 0 { |
|
cond = append(cond, "((permission & ?) = ?)") |
|
values = append(values, permission, permission) |
|
} |
|
if checkSort(arg.SortUP, orderSign) { |
|
arg.Order = "ds.up_count" |
|
arg.Sort = arg.SortUP |
|
orderSign = true |
|
} |
|
if checkSort(arg.SortAllFans, orderSign) { |
|
arg.Order = "ds.fans_count_accumulate" |
|
arg.Sort = arg.SortAllFans |
|
orderSign = true |
|
} |
|
if checkSort(arg.SortRiseFans, orderSign) { |
|
arg.Order = "ds.fans_count_online_accumulate" |
|
arg.Sort = arg.SortRiseFans |
|
orderSign = true |
|
} |
|
if checkSort(arg.SortTrueRiseFans, orderSign) { |
|
arg.Order = "ds.fans_count_real_accumulate" |
|
arg.Sort = arg.SortTrueRiseFans |
|
orderSign = true |
|
} |
|
if checkSort(arg.SortCheatFans, orderSign) { |
|
arg.Order = "ds.fans_count_cheat_accumulate" |
|
arg.Sort = arg.SortCheatFans |
|
} |
|
condStr = d.joinStringSQL(cond) |
|
switch SQLType { |
|
case "list": |
|
if arg.Export == model.ResponeModelCSV { |
|
sql = fmt.Sprintf(_selMCNListSQL+_orderByConditionNotLimitSQL, condStr, arg.Order, arg.Sort) |
|
return |
|
} |
|
sql = fmt.Sprintf(_selMCNListSQL+_orderByConditionSQL, condStr, arg.Order, arg.Sort) |
|
limit, offset := arg.PageArg.CheckPageValidation() |
|
values = append(values, offset, limit) |
|
case "count": |
|
sql = fmt.Sprintf(_countMCNListSQL, condStr) |
|
} |
|
return |
|
} |
|
|
|
func checkSort(arg string, orderSign bool) bool { |
|
return arg != "" && (arg == "asc" || arg == "desc") && !orderSign |
|
} |
|
|
|
// MCNListTotal . |
|
func (d *Dao) MCNListTotal(c context.Context, arg *model.MCNListReq) (count int64, err error) { |
|
sql, values := d.buildMCNListSQL("count", arg) |
|
row := d.db.QueryRow(c, sql, values...) |
|
if err = row.Scan(&count); err != nil { |
|
if err == xsql.ErrNoRows { |
|
err = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// MCNPayInfo . |
|
func (d *Dao) MCNPayInfo(c context.Context, arg *model.MCNPayStateEditReq) (m *model.SignPayInfoReply, err error) { |
|
row := d.db.QueryRow(c, _selMCNPayInfosByID, arg.ID) |
|
m = new(model.SignPayInfoReply) |
|
// id,mcn_mid,sign_id,due_date,pay_value,state |
|
if err = row.Scan(&m.SignPayID, &m.McnMid, &m.SignID, &m.DueDate, &m.PayValue, &m.State); err != nil { |
|
if err == xsql.ErrNoRows { |
|
err = nil |
|
m = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// MCNPayInfos . |
|
func (d *Dao) MCNPayInfos(c context.Context, ids []int64) (res map[int64][]*model.SignPayInfoReply, err error) { |
|
rows, err := d.db.Query(c, fmt.Sprintf(_selMCNPayInfosBySignIDsSQL, xstr.JoinInts(ids))) |
|
if err != nil { |
|
return |
|
} |
|
defer rows.Close() |
|
res = make(map[int64][]*model.SignPayInfoReply, len(ids)) |
|
for rows.Next() { |
|
m := &model.SignPayInfoReply{} |
|
err = rows.Scan(&m.SignPayID, &m.McnMid, &m.SignID, &m.DueDate, &m.PayValue, &m.State) |
|
if err != nil { |
|
return |
|
} |
|
res[m.SignID] = append(res[m.SignID], m) |
|
} |
|
return |
|
} |
|
|
|
// TxMCNRenewalUPs . |
|
func (d *Dao) TxMCNRenewalUPs(tx *xsql.Tx, signID, mcnID int64) (ups []*model.MCNUP, err error) { |
|
var rows *xsql.Rows |
|
if rows, err = tx.Query(_selMCNRenewalUPsSQL, signID, mcnID); err != nil { |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
up := new(model.MCNUP) |
|
if err = rows.Scan(&up.SignID, &up.MCNMID, &up.UPMID, &up.BeginDate, &up.EndDate, &up.ContractLink, |
|
&up.UPAuthLink, &up.RejectReason, &up.RejectTime, &up.State, &up.StateChangeTime, &up.UpType, |
|
&up.SiteLink, &up.ConfirmTime, &up.Permission, &up.PublicationPrice); err != nil { |
|
return |
|
} |
|
ups = append(ups, up) |
|
} |
|
err = rows.Err() |
|
return |
|
} |
|
|
|
// MCNInfo . |
|
func (d *Dao) MCNInfo(c context.Context, arg *model.MCNInfoReq) (m *model.MCNInfoReply, err error) { |
|
row := d.db.QueryRow(c, _selMCNInfoSQL, model.AllActiveTid, arg.ID) |
|
m = new(model.MCNInfoReply) |
|
if err = row.Scan(&m.ID, &m.MCNMID, &m.CompanyName, &m.CompanyLicenseID, &m.CompanyLicenseLink, &m.ContractLink, &m.ContactName, |
|
&m.ContactTitle, &m.ContactIdcard, &m.ContactPhone, &m.BeginDate, &m.EndDate, &m.State, &m.UPCount, &m.FansCountAccumulate, |
|
&m.ArchiveCountAccumulate, &m.PlayCountAccumulate, &m.FansCountOnline, &m.FansCountRealAccumulate, &m.FansCountOnlineAccumulate); err != nil { |
|
if err == xsql.ErrNoRows { |
|
err = nil |
|
m = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// MCNUPList . |
|
func (d *Dao) MCNUPList(c context.Context, arg *model.MCNUPListReq) (res []*model.MCNUPInfoReply, err error) { |
|
sql, values := d.buildMCNUPListSQL("list", arg) |
|
rows, err := d.db.Query(c, sql, values...) |
|
if err != nil { |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
m := &model.MCNUPInfoReply{} |
|
err = rows.Scan(&m.SignUpID, &m.SignID, &m.McnMid, &m.UpMid, &m.PubPrice, &m.Permission, &m.ActiveTid, &m.FansCount, &m.FansCountActive, |
|
&m.BeginDate, &m.EndDate, &m.State, &m.FansIncreaseAccumulate, &m.ArchiveCount, &m.PlayCount, &m.ContractLink, &m.UpAuthLink, &m.UPType, &m.SiteLink) |
|
if err != nil { |
|
return |
|
} |
|
res = append(res, m) |
|
} |
|
return |
|
} |
|
|
|
// MCNUPListTotal . |
|
func (d *Dao) MCNUPListTotal(c context.Context, arg *model.MCNUPListReq) (count int64, err error) { |
|
sql, values := d.buildMCNUPListSQL("count", arg) |
|
row := d.db.QueryRow(c, sql, values...) |
|
if err = row.Scan(&count); err != nil { |
|
if err == xsql.ErrNoRows { |
|
err = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// buildMCNUPListSQL build a MCNUPList sql string. |
|
func (d *Dao) buildMCNUPListSQL(SQLType string, arg *model.MCNUPListReq) (sql string, values []interface{}) { |
|
values = make([]interface{}, 0, 8) |
|
var ( |
|
cond []string |
|
condStr string |
|
orderSign = false |
|
) |
|
values = append(values, arg.DataType) |
|
cond = append(cond, "u.sign_id=?") |
|
values = append(values, arg.SignID) |
|
if arg.FansNumMin != 0 { |
|
cond = append(cond, "du.fans_count>=?") |
|
values = append(values, arg.FansNumMin) |
|
} |
|
if arg.FansNumMax != 0 && arg.FansNumMax >= arg.FansNumMin { |
|
cond = append(cond, "du.fans_count<=?") |
|
values = append(values, arg.FansNumMax) |
|
} |
|
if arg.ActiveTID != 0 { |
|
cond = append(cond, "du.active_tid=?") |
|
values = append(values, arg.ActiveTID) |
|
} |
|
if arg.State != -1 { |
|
cond = append(cond, "u.state=?") |
|
values = append(values, arg.State) |
|
} |
|
if arg.UPMID != 0 { |
|
cond = append(cond, "u.up_mid=?") |
|
values = append(values, arg.UPMID) |
|
} |
|
if arg.UpType != -1 { |
|
cond = append(cond, "u.up_type=?") |
|
values = append(values, arg.UpType) |
|
} |
|
|
|
var permission = arg.GetAttrPermitVal() |
|
if permission != 0 { |
|
cond = append(cond, "((permission & ?) = ?)") |
|
values = append(values, permission, permission) |
|
} |
|
if checkSort(arg.SortFansCount, orderSign) { |
|
arg.Order = "du.fans_count" |
|
arg.Sort = arg.SortFansCount |
|
orderSign = true |
|
} |
|
if checkSort(arg.SortFansCountActive, orderSign) { |
|
arg.Order = "du.fans_count_active" |
|
arg.Sort = arg.SortFansCountActive |
|
orderSign = true |
|
} |
|
if checkSort(arg.SortFansIncreaseAccumulate, orderSign) { |
|
arg.Order = "du.fans_increase_accumulate" |
|
arg.Sort = arg.SortFansIncreaseAccumulate |
|
orderSign = true |
|
} |
|
if checkSort(arg.SortArchiveCount, orderSign) { |
|
arg.Order = "du.archive_count" |
|
arg.Sort = arg.SortArchiveCount |
|
orderSign = true |
|
} |
|
if checkSort(arg.SortPlayCount, orderSign) { |
|
arg.Order = "du.play_count" |
|
arg.Sort = arg.SortPlayCount |
|
orderSign = true |
|
} |
|
if checkSort(arg.SortPubPrice, orderSign) { |
|
arg.Order = "u.publication_price" |
|
arg.Sort = arg.SortPubPrice |
|
} |
|
condStr = d.joinStringSQL(cond) |
|
switch SQLType { |
|
case "list": |
|
if arg.Export == model.ResponeModelCSV { |
|
sql = fmt.Sprintf(_selMCNUPListSQL+_orderByConditionNotLimitSQL, condStr, arg.Order, arg.Sort) |
|
return |
|
} |
|
sql = fmt.Sprintf(_selMCNUPListSQL+_orderByConditionSQL, condStr, arg.Order, arg.Sort) |
|
limit, offset := arg.PageArg.CheckPageValidation() |
|
values = append(values, offset, limit) |
|
case "count": |
|
sql = fmt.Sprintf(_countMCNUPListSQL, condStr) |
|
fmt.Println(sql) |
|
} |
|
return |
|
} |
|
|
|
// UpMCNUPState . |
|
func (d *Dao) UpMCNUPState(c context.Context, arg *model.MCNUPStateEditReq) (rows int64, err error) { |
|
var res sql.Result |
|
if res, err = d.db.Exec(c, _upMCNUPStateSQL, arg.State, time.Now(), arg.ID, arg.SignID, arg.MCNMID, arg.UPMID); err != nil { |
|
return rows, err |
|
} |
|
return res.RowsAffected() |
|
} |
|
|
|
// McnSignByMCNMID . |
|
func (d *Dao) McnSignByMCNMID(c context.Context, MCNID int64) (m *model.MCNSignInfoReply, err error) { |
|
row := d.db.QueryRow(c, _selMCNByMCNMIDSQL, MCNID) |
|
m = new(model.MCNSignInfoReply) |
|
if err = row.Scan(&m.SignID, &m.McnMid, &m.CompanyName, &m.CompanyLicenseID, &m.CompanyLicenseLink, &m.ContractLink, &m.ContactName, |
|
&m.ContactTitle, &m.ContactIdcard, &m.ContactPhone, &m.BeginDate, &m.EndDate, &m.RejectReason, &m.RejectTime, &m.State, &m.Ctime, &m.Mtime); err != nil { |
|
if err == xsql.ErrNoRows { |
|
err = nil |
|
m = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// MCNCheatList . |
|
func (d *Dao) MCNCheatList(c context.Context, arg *model.MCNCheatListReq) (res []*model.MCNCheatReply, mids []int64, err error) { |
|
sql, values := d.buildMCNCheatListSQL("list", arg) |
|
rows, err := d.db.Query(c, sql, values...) |
|
if err != nil { |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
m := &model.MCNCheatReply{} |
|
err = rows.Scan(&m.FansCountReal, &m.FansCountCheatAccumulate, &m.MCNMID, &m.SignID, &m.UpMID, &m.FansCountCheatIncreaseDay, &m.FansCountCheatCleanedAccumulate) |
|
if err != nil { |
|
return |
|
} |
|
|
|
res = append(res, m) |
|
mids = append(mids, m.UpMID, m.MCNMID) |
|
} |
|
mids = SliceUnique(mids) |
|
return |
|
} |
|
|
|
// MCNCheatListTotal . |
|
func (d *Dao) MCNCheatListTotal(c context.Context, arg *model.MCNCheatListReq) (count int64, err error) { |
|
sql, values := d.buildMCNCheatListSQL("count", arg) |
|
row := d.db.QueryRow(c, sql, values...) |
|
if err = row.Scan(&count); err != nil { |
|
if err == xsql.ErrNoRows { |
|
err = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
//SliceUnique unique |
|
func SliceUnique(s []int64) []int64 { |
|
result := make([]int64, 0, len(s)) |
|
temp := map[int64]struct{}{} |
|
for _, item := range s { |
|
if _, ok := temp[item]; !ok { |
|
temp[item] = struct{}{} |
|
result = append(result, item) |
|
} |
|
} |
|
return result |
|
} |
|
|
|
// buildMCNCheatListSQL build a MCNCheatList sql string. |
|
func (d *Dao) buildMCNCheatListSQL(SQLType string, arg *model.MCNCheatListReq) (sql string, values []interface{}) { |
|
values = make([]interface{}, 0, 3) |
|
var ( |
|
cond []string |
|
condStr string |
|
) |
|
cond = append(cond, "generate_date=(SELECT generate_date FROM mcn_data_up_cheat ORDER BY generate_date DESC LIMIT 1)") |
|
if arg.MCNMID > 0 { |
|
cond = append(cond, "mcn_mid=?") |
|
values = append(values, arg.MCNMID) |
|
} |
|
if arg.UPMID > 0 { |
|
cond = append(cond, "up_mid=?") |
|
values = append(values, arg.UPMID) |
|
} |
|
condStr = d.joinStringSQL(cond) |
|
switch SQLType { |
|
case "list": |
|
sql = fmt.Sprintf(_selMCNCheatListSQL+_orderByConditionSQL, condStr, "generate_date DESC,fans_count_cheat_accumulate", "DESC") |
|
limit, offset := arg.PageArg.CheckPageValidation() |
|
values = append(values, offset, limit) |
|
case "count": |
|
sql = fmt.Sprintf(_countMCNCheatListSQL, condStr) |
|
} |
|
return |
|
} |
|
|
|
// MCNCheatUPList . |
|
func (d *Dao) MCNCheatUPList(c context.Context, arg *model.MCNCheatUPListReq) (res []*model.MCNCheatUPReply, err error) { |
|
limit, offset := arg.PageArg.CheckPageValidation() |
|
rows, err := d.db.Query(c, _selMCNCheatUPListSQL, arg.UPMID, offset, limit) |
|
if err != nil { |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
m := &model.MCNCheatUPReply{} |
|
err = rows.Scan(&m.SignID, &m.GenerateDate, &m.FansCountReal, &m.FansCountCheatAccumulate, &m.MCNMID, &m.FansCountCheatIncreaseDay, &m.FansCountCheatCleanedAccumulate) |
|
if err != nil { |
|
return |
|
} |
|
res = append(res, m) |
|
} |
|
return |
|
} |
|
|
|
// MCNCheatUPListTotal . |
|
func (d *Dao) MCNCheatUPListTotal(c context.Context, arg *model.MCNCheatUPListReq) (count int64, err error) { |
|
row := d.db.QueryRow(c, _countMCNCheatUPListSQL, arg.UPMID) |
|
if err = row.Scan(&count); err != nil { |
|
if err == xsql.ErrNoRows { |
|
err = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// MCNImportUPInfo . |
|
func (d *Dao) MCNImportUPInfo(c context.Context, arg *model.MCNImportUPInfoReq) (m *model.MCNImportUPInfoReply, err error) { |
|
row := d.db.QueryRow(c, _selMCNImportUPInfoSQL, arg.SignID, arg.UPMID) |
|
m = new(model.MCNImportUPInfoReply) |
|
if err = row.Scan(&m.ID, &m.MCNMID, &m.SignID, &m.UpMID, &m.StandardFansDate, &m.StandardArchiveCount, &m.StandardFansCount, &m.IsReward); err != nil { |
|
if err == xsql.ErrNoRows { |
|
err = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// MCNIncreaseList . |
|
func (d *Dao) MCNIncreaseList(c context.Context, arg *model.MCNIncreaseListReq) (res []*model.MCNIncreaseReply, err error) { |
|
sql, values := d.buildMCNIncreaseListSQL("list", arg) |
|
rows, err := d.db.Query(c, sql, values...) |
|
if err != nil { |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
m := &model.MCNIncreaseReply{} |
|
err = rows.Scan(&m.ID, &m.SignID, &m.DataType, &m.ActiveTID, &m.GenerateDate, &m.UPCount, &m.FansCountOnlineAccumulate, &m.FansCountRealAccumulate, &m.FansCountCheatAccumulate, &m.FansCountIncreaseDay, |
|
&m.ArchiveCountAccumulate, &m.ArchiveCountDay, &m.PlayCountAccumulate, &m.PlayCountIncreaseDay, &m.FansCountAccumulate) |
|
if err != nil { |
|
return |
|
} |
|
res = append(res, m) |
|
} |
|
return |
|
} |
|
|
|
// MCNIncreaseListTotal . |
|
func (d *Dao) MCNIncreaseListTotal(c context.Context, arg *model.MCNIncreaseListReq) (count int64, err error) { |
|
sql, values := d.buildMCNIncreaseListSQL("count", arg) |
|
row := d.db.QueryRow(c, sql, values...) |
|
if err = row.Scan(&count); err != nil { |
|
if err == xsql.ErrNoRows { |
|
err = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// buildMCNIncreaseListSQL build a MCNIncreaseList sql string. |
|
func (d *Dao) buildMCNIncreaseListSQL(SQLType string, arg *model.MCNIncreaseListReq) (sql string, values []interface{}) { |
|
values = make([]interface{}, 0, 3) |
|
var ( |
|
cond []string |
|
condStr string |
|
) |
|
cond = append(cond, "sign_id=?") |
|
values = append(values, arg.SignID) |
|
if arg.DataType > 0 { |
|
cond = append(cond, "data_type=?") |
|
values = append(values, arg.DataType) |
|
} |
|
if arg.ActiveTID == 0 { |
|
arg.ActiveTID = model.AllActiveTid |
|
} |
|
if arg.ActiveTID > 0 { |
|
cond = append(cond, "active_tid=?") |
|
values = append(values, arg.ActiveTID) |
|
} |
|
condStr = d.joinStringSQL(cond) |
|
switch SQLType { |
|
case "list": |
|
sql = fmt.Sprintf(_selMCNDataSummaryListSQL+_orderByConditionSQL, condStr, "generate_date", "DESC") |
|
limit, offset := arg.PageArg.CheckPageValidation() |
|
values = append(values, offset, limit) |
|
case "count": |
|
sql = fmt.Sprintf(_countMCNDataSummaryListSQL, condStr) |
|
} |
|
return |
|
}
|
|
|