1026 lines
43 KiB
Go
1026 lines
43 KiB
Go
package income
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"go-common/app/job/main/growup/conf"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
model "go-common/app/job/main/growup/model/income"
|
|
xtime "go-common/library/time"
|
|
|
|
. "github.com/smartystreets/goconvey/convey"
|
|
)
|
|
|
|
func Test_Run(t *testing.T) {
|
|
Convey("Test Run creative one day one record\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
date := "2018-06-01"
|
|
dateSec := "2018-06-01 15:02:03"
|
|
d, _ := time.ParseInLocation("2006-01-02", date, time.Local)
|
|
ac := insertAvDailyCharge(c, date, dateSec, 1101, 110, 10)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
|
|
var totalIncome, taxMoney, count int64 = 10, 0, 1
|
|
checkAllData(c, ac, totalIncome, taxMoney, count, date)
|
|
})
|
|
}
|
|
|
|
func Test_RunWithBubble(t *testing.T) {
|
|
var (
|
|
c = context.TODO()
|
|
date = time.Now()
|
|
avid = int64(2333)
|
|
mid = int64(233)
|
|
charge = int64(10)
|
|
err error
|
|
)
|
|
Convey("Test Run ", t, func() {
|
|
deleteAll(c)
|
|
s.conf.Bubble = &conf.BubbleConfig{BRatio: []*conf.BRatio{{BType: 1, Ratio: 0.8}}}
|
|
insertBubbleMeta(c, fmt.Sprintf("(%d,%d,'%s')", avid, 1, date.Format("2006-01-02")))
|
|
dailyCharge := insertAvDailyCharge(c, date.Format("2006-01-02"), date.Format("2006-01-02 15:04:05"), avid, mid, charge)
|
|
err = s.run(c, date)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, date)
|
|
So(err, ShouldBeNil)
|
|
checkAllData(c, dailyCharge, 8, 0, 1, date.Format("2006-01-02"))
|
|
})
|
|
}
|
|
|
|
func Test_RunWithMultiBubble(t *testing.T) {
|
|
var (
|
|
c = context.TODO()
|
|
date = time.Now()
|
|
avid = int64(2333)
|
|
mid = int64(233)
|
|
charge = int64(10)
|
|
err error
|
|
)
|
|
Convey("Test Run ", t, func() {
|
|
deleteAll(c)
|
|
s.conf.Bubble = &conf.BubbleConfig{BRatio: []*conf.BRatio{{BType: 1, Ratio: 0.8}, {BType: 2, Ratio: 0.7}}}
|
|
insertBubbleMeta(c, fmt.Sprintf("(%d,%d,'%s')", avid, 1, date.Format("2006-01-02")))
|
|
insertBubbleMeta(c, fmt.Sprintf("(%d,%d,'%s')", avid, 2, date.Format("2006-01-02")))
|
|
dailyCharge := insertAvDailyCharge(c, date.Format("2006-01-02"), date.Format("2006-01-02 15:04:05"), avid, mid, charge)
|
|
err = s.run(c, date)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, date)
|
|
So(err, ShouldBeNil)
|
|
checkAllData(c, dailyCharge, 7, 0, 1, date.Format("2006-01-02"))
|
|
})
|
|
}
|
|
|
|
func Test_AvIncome(t *testing.T) {
|
|
Convey("Test av income\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
ac1 := insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
ac2 := insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
avIncome1 := checkAvIncome(c, ac1, 10, 0, 1, "2018-06-01")
|
|
avIncome2 := checkAvIncome(c, ac2, 10, 0, 1, "2018-06-01")
|
|
checkAvIncomeStatis(c, avIncome1, 10)
|
|
checkAvIncomeStatis(c, avIncome2, 10)
|
|
|
|
ac3 := insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1101, 110, 20)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-02", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
avIncome3 := checkAvIncome(c, ac3, 30, 0, 1, "2018-06-02")
|
|
checkAvIncomeStatis(c, avIncome2, 10)
|
|
checkAvIncomeStatis(c, avIncome3, 30)
|
|
|
|
ac3 = insertAvDailyCharge(c, "2018-07-01", "2018-06-01 15:02:03", 1101, 110, 20)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-07-01", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
avIncome3 = checkAvIncome(c, ac3, 50, 0, 1, "2018-07-01")
|
|
checkAvIncomeStatis(c, avIncome3, 50)
|
|
})
|
|
}
|
|
|
|
func Test_AvIncomeDateStatis(t *testing.T) {
|
|
Convey("Test av income daily weekly monthly statis\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1103, 110, 3500)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkAvIncomeDateStatis(c, 0, 2, 1, 3494, 12, d, "av_income_daily_statis")
|
|
checkAvIncomeDateStatis(c, 4, 1, 1, 3494, 12, d, "av_income_daily_statis")
|
|
weekD := getStartWeeklyDate(d)
|
|
checkAvIncomeDateStatis(c, 0, 2, 1, 3494, 12, weekD, "av_income_weekly_statis")
|
|
checkAvIncomeDateStatis(c, 4, 1, 1, 3494, 12, weekD, "av_income_weekly_statis")
|
|
monthD := getStartMonthlyDate(d)
|
|
checkAvIncomeDateStatis(c, 0, 2, 1, 3494, 12, monthD, "av_income_monthly_statis")
|
|
checkAvIncomeDateStatis(c, 4, 1, 1, 3494, 12, monthD, "av_income_monthly_statis")
|
|
|
|
// insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1101, 110, 1000)
|
|
// insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1102, 110, 1000)
|
|
// insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1103, 110, 4000)
|
|
// d, _ = time.ParseInLocation("2006-01-02", "2018-06-02", time.Local)
|
|
// err = s.run(c, d)
|
|
// So(err, ShouldBeNil)
|
|
// checkAvIncomeDateStatis(c, 0, 2, 1, 5801, 12, d, "av_income_daily_statis")
|
|
// checkAvIncomeDateStatis(c, 1, 1, 1, 5801, 12, d, "av_income_daily_statis")
|
|
// weekD = getStartWeeklyDate(d)
|
|
// income := 5801 + 3494
|
|
// checkAvIncomeDateStatis(c, 0, 2, 1, income, 12, weekD, "av_income_weekly_statis")
|
|
// checkAvIncomeDateStatis(c, 1, 0, 1, income, 12, weekD, "av_income_weekly_statis")
|
|
// checkAvIncomeDateStatis(c, 2, 1, 1, income, 12, weekD, "av_income_weekly_statis")
|
|
// monthD = getStartMonthlyDate(d)
|
|
// checkAvIncomeDateStatis(c, 0, 2, 1, income, 12, monthD, "av_income_monthly_statis")
|
|
// checkAvIncomeDateStatis(c, 1, 0, 1, income, 12, monthD, "av_income_monthly_statis")
|
|
// checkAvIncomeDateStatis(c, 2, 1, 1, income, 12, monthD, "av_income_monthly_statis")
|
|
|
|
// insertAvDailyCharge(c, "2018-06-10", "2018-06-01 15:02:03", 1101, 110, 15000)
|
|
// insertAvDailyCharge(c, "2018-06-10", "2018-06-01 15:02:03", 1102, 110, 15000)
|
|
// insertAvDailyCharge(c, "2018-06-10", "2018-06-01 15:02:03", 1103, 110, 40000)
|
|
// d, _ = time.ParseInLocation("2006-01-02", "2018-06-10", time.Local)
|
|
// err = s.run(c, d)
|
|
// So(err, ShouldBeNil)
|
|
// checkAvIncomeDateStatis(c, 0, 0, 1, 54651, 12, d, "av_income_daily_statis")
|
|
// checkAvIncomeDateStatis(c, 1, 0, 1, 54651, 12, d, "av_income_daily_statis")
|
|
// checkAvIncomeDateStatis(c, 3, 2, 1, 54651, 12, d, "av_income_daily_statis")
|
|
// checkAvIncomeDateStatis(c, 4, 1, 1, 54651, 12, d, "av_income_daily_statis")
|
|
// weekD = getStartWeeklyDate(d)
|
|
// checkAvIncomeDateStatis(c, 0, 0, 1, 54651, 12, weekD, "av_income_weekly_statis")
|
|
// checkAvIncomeDateStatis(c, 1, 0, 1, 54651, 12, weekD, "av_income_weekly_statis")
|
|
// checkAvIncomeDateStatis(c, 3, 2, 1, 54651, 12, weekD, "av_income_weekly_statis")
|
|
// checkAvIncomeDateStatis(c, 4, 1, 1, 54651, 12, weekD, "av_income_weekly_statis")
|
|
// monthD = getStartMonthlyDate(d)
|
|
// checkAvIncomeDateStatis(c, 0, 0, 1, 63946, 12, monthD, "av_income_monthly_statis")
|
|
// checkAvIncomeDateStatis(c, 1, 0, 1, 63946, 12, monthD, "av_income_monthly_statis")
|
|
// checkAvIncomeDateStatis(c, 3, 2, 1, 63946, 12, monthD, "av_income_monthly_statis")
|
|
// checkAvIncomeDateStatis(c, 4, 1, 1, 63946, 12, monthD, "av_income_monthly_statis")
|
|
|
|
// insertAvDailyCharge(c, "2018-07-10", "2018-06-01 15:02:03", 1101, 110, 100)
|
|
// d, _ = time.ParseInLocation("2006-01-02", "2018-07-10", time.Local)
|
|
// err = s.run(c, d)
|
|
// So(err, ShouldBeNil)
|
|
// monthD = getStartMonthlyDate(d)
|
|
// checkAvIncomeDateStatis(c, 0, 1, 1, 100, 12, monthD, "av_income_monthly_statis")
|
|
// checkAvIncomeDateStatis(c, 1, 0, 1, 100, 12, monthD, "av_income_monthly_statis")
|
|
})
|
|
}
|
|
|
|
func Test_UpIncome(t *testing.T) {
|
|
Convey("Test up income\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
ac1 := insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
ac2 := insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
avIncome1 := checkAvIncome(c, ac1, 10, 0, 1, "2018-06-01")
|
|
avIncome2 := checkAvIncome(c, ac2, 10, 0, 1, "2018-06-01")
|
|
avs := []*model.AvIncome{avIncome1, avIncome2}
|
|
up := checkUpIncome(c, avs, 20, "up_income", "", 2)
|
|
checkUpIncomeWeekly(c, avs, 20, 2)
|
|
checkUpIncomeMonthly(c, avs, 20, 2)
|
|
checkUpIncomeStatis(c, up.MID, 20)
|
|
|
|
ac3 := insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
ac4 := insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
ac5 := insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1103, 110, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-02", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
|
|
avIncome3 := checkAvIncome(c, ac3, 20, 0, 1, "2018-06-02")
|
|
avIncome4 := checkAvIncome(c, ac4, 20, 0, 1, "2018-06-02")
|
|
avIncome5 := checkAvIncome(c, ac5, 10, 0, 1, "2018-06-02")
|
|
avs = append(avs, avIncome3)
|
|
avs = append(avs, avIncome4)
|
|
avs = append(avs, avIncome5)
|
|
up = checkUpIncome(c, []*model.AvIncome{avIncome3, avIncome4, avIncome5}, 50, "up_income", "", 3)
|
|
checkUpIncomeWeekly(c, avs, 50, 3)
|
|
checkUpIncomeMonthly(c, avs, 50, 3)
|
|
checkUpIncomeStatis(c, up.MID, 50)
|
|
checkUpAccount(c, 110, 50, 50, 0, "2018-05")
|
|
})
|
|
}
|
|
|
|
func Test_UpIncomeDailyStatis(t *testing.T) {
|
|
Convey("Test up income daily statis\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1103, 111, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpIncomeDailyStatis(c, 0, 2, 30, d)
|
|
|
|
insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1101, 110, 10000)
|
|
insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1102, 111, 30000)
|
|
insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1103, 110, 70000)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-02", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpIncomeDailyStatis(c, 7, 1, 87300, d)
|
|
checkUpIncomeDailyStatis(c, 8, 1, 87300, d)
|
|
})
|
|
}
|
|
|
|
func Test_UpIncomeStatis(t *testing.T) {
|
|
Convey("Test up income statis\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1103, 111, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpIncomeStatis(c, 110, 20)
|
|
checkUpIncomeStatis(c, 111, 10)
|
|
|
|
insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1103, 111, 10)
|
|
insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1104, 112, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-02", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpIncomeStatis(c, 110, 40)
|
|
checkUpIncomeStatis(c, 111, 20)
|
|
checkUpIncomeStatis(c, 112, 10)
|
|
|
|
insertAvDailyCharge(c, "2018-07-02", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-07-02", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
insertAvDailyCharge(c, "2018-07-02", "2018-06-01 15:02:03", 1103, 111, 10)
|
|
insertAvDailyCharge(c, "2018-07-02", "2018-06-01 15:02:03", 1104, 112, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-07-02", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpIncomeStatis(c, 110, 60)
|
|
checkUpIncomeStatis(c, 111, 30)
|
|
checkUpIncomeStatis(c, 112, 20)
|
|
})
|
|
}
|
|
|
|
func Test_AvIncomeTag(t *testing.T) {
|
|
Convey("Test av income tag\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
s.dao.Exec(c, "insert into av_charge_ratio(av_id,ratio,adjust_type) values(1101,200,0)")
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkAvIncomeTag(c, 1101, 20, 0, 20, "2018-06-01")
|
|
|
|
s.dao.Exec(c, "delete from av_charge_ratio")
|
|
s.dao.Exec(c, "insert into av_charge_ratio(av_id,ratio,adjust_type) values(1101,20,1)")
|
|
insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-02", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkAvIncomeTag(c, 1101, 30, 0, 50, "2018-06-02")
|
|
|
|
// tax
|
|
s.dao.Exec(c, "delete from av_charge_ratio")
|
|
s.dao.Exec(c, "insert into av_charge_ratio(av_id,ratio,adjust_type) values(1101,20000,1)")
|
|
insertAvDailyCharge(c, "2018-06-03", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-03", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkAvIncomeTag(c, 1101, 20010, 0, 20060, "2018-06-03")
|
|
})
|
|
}
|
|
|
|
func Test_IncomeTax(t *testing.T) {
|
|
Convey("Test income tax\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 3000)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1102, 111, 4000)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1103, 112, 8000)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1104, 113, 12000)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1105, 114, 18000)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1106, 115, 40000)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1107, 116, 80000)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1108, 117, 150000)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1109, 118, 250000)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 11010, 119, 500000)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkAvIncomeTag(c, 1101, 3000, 0, 3000, "2018-06-01")
|
|
checkAvIncomeTag(c, 1102, 3950, 50, 3950, "2018-06-01")
|
|
checkAvIncomeTag(c, 1103, 7600, 400, 7600, "2018-06-01")
|
|
checkAvIncomeTag(c, 1104, 11100, 900, 11100, "2018-06-01")
|
|
checkAvIncomeTag(c, 1105, 16050, 1950, 16050, "2018-06-01")
|
|
checkAvIncomeTag(c, 1106, 33150, 6850, 33150, "2018-06-01")
|
|
checkAvIncomeTag(c, 1107, 61650, 18350, 61650, "2018-06-01")
|
|
checkAvIncomeTag(c, 1108, 105650, 44350, 105650, "2018-06-01")
|
|
checkAvIncomeTag(c, 1109, 160650, 89350, 160650, "2018-06-01")
|
|
checkAvIncomeTag(c, 11010, 265650, 234350, 265650, "2018-06-01")
|
|
})
|
|
}
|
|
|
|
func Test_UpIncomeTag(t *testing.T) {
|
|
Convey("Test up income tag\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
s.dao.Exec(c, "insert into up_charge_ratio(mid,ratio,adjust_type) values(110,200,0)")
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpIncomeTag(c, 110, 20, 0, 20, "2018-06-01", "up_income")
|
|
|
|
s.dao.Exec(c, "delete from up_charge_ratio")
|
|
s.dao.Exec(c, "insert into up_charge_ratio(mid,ratio,adjust_type) values(110,20000,1)")
|
|
insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-02", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpIncomeTag(c, 110, 20010, 0, 20030, "2018-06-02", "up_income")
|
|
|
|
// av ratio + up ratio float + float
|
|
s.dao.Exec(c, "delete from av_charge_ratio")
|
|
s.dao.Exec(c, "delete from up_charge_ratio")
|
|
s.dao.Exec(c, "insert into av_charge_ratio(av_id,ratio,adjust_type) values(1101,200,0)")
|
|
s.dao.Exec(c, "insert into up_charge_ratio(mid,ratio,adjust_type) values(110,200,0)")
|
|
insertAvDailyCharge(c, "2018-06-03", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-03", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-03", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
var income int64 = (10*2 + 10) * 2
|
|
checkUpIncomeTag(c, 110, income, 0, 20030+income, "2018-06-03", "up_income")
|
|
|
|
// av ratio + up ratio float + fixed
|
|
s.dao.Exec(c, "delete from av_charge_ratio")
|
|
s.dao.Exec(c, "delete from up_charge_ratio")
|
|
s.dao.Exec(c, "insert into av_charge_ratio(av_id,ratio,adjust_type) values(1101,200,0)")
|
|
s.dao.Exec(c, "insert into up_charge_ratio(mid,ratio,adjust_type) values(110,200,1)")
|
|
insertAvDailyCharge(c, "2018-06-04", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-04", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-04", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
var income1 int64 = (10*2 + 10) + 200
|
|
checkUpIncomeTag(c, 110, income1, 0, 20030+income+income1, "2018-06-04", "up_income")
|
|
|
|
// av ratio + up ratio fixed + float
|
|
s.dao.Exec(c, "delete from av_charge_ratio")
|
|
s.dao.Exec(c, "delete from up_charge_ratio")
|
|
s.dao.Exec(c, "insert into av_charge_ratio(av_id,ratio,adjust_type) values(1101,200,1)")
|
|
s.dao.Exec(c, "insert into up_charge_ratio(mid,ratio,adjust_type) values(110,200,0)")
|
|
insertAvDailyCharge(c, "2018-06-05", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-05", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-05", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
var income2 int64 = 10*2 + 200 + 10*2
|
|
checkUpIncomeTag(c, 110, income2, 0, 20030+income+income1+income2, "2018-06-05", "up_income")
|
|
|
|
// av ratio + up ratio fixed + fixed
|
|
s.dao.Exec(c, "delete from av_charge_ratio")
|
|
s.dao.Exec(c, "delete from up_charge_ratio")
|
|
s.dao.Exec(c, "insert into av_charge_ratio(av_id,ratio,adjust_type) values(1101,200,1)")
|
|
s.dao.Exec(c, "insert into up_charge_ratio(mid,ratio,adjust_type) values(110,200,1)")
|
|
insertAvDailyCharge(c, "2018-06-06", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-06", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-06", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
var income3 int64 = 10 + 10 + 200 + 200
|
|
checkUpIncomeTag(c, 110, income3, 0, 20030+income+income1+income2+income3, "2018-06-06", "up_income")
|
|
})
|
|
}
|
|
|
|
// black_list
|
|
func Test_AvBlackList(t *testing.T) {
|
|
Convey("Test av black list\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
s.dao.Exec(c, "insert into av_black_list(av_id,mid,reason) values(1101,110,1)")
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
var count int
|
|
s.dao.QueryRow(c, "select count(*) from av_income").Scan(&count)
|
|
So(count, ShouldEqual, 0)
|
|
s.dao.QueryRow(c, "select count(*) from up_income").Scan(&count)
|
|
So(count, ShouldEqual, 0)
|
|
})
|
|
}
|
|
|
|
func Test_UpInfoVideo(t *testing.T) {
|
|
Convey("Test up_info_video\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
s.dao.Exec(c, "delete from up_info_video where mid = 1115")
|
|
s.dao.Exec(c, "insert into up_info_video(mid,account_type,account_state,signed_at) values(1115,1,4,'2018-05-30')")
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 20:02:03", 1101, 1115, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
var count int
|
|
s.dao.QueryRow(c, "select count(*) from av_income").Scan(&count)
|
|
So(count, ShouldEqual, 0)
|
|
s.dao.QueryRow(c, "select count(*) from up_income").Scan(&count)
|
|
So(count, ShouldEqual, 0)
|
|
s.dao.Exec(c, "delete from up_info_video where mid = 1115")
|
|
|
|
deleteAll(c)
|
|
s.dao.Exec(c, "delete from up_info_video where mid = 1115")
|
|
s.dao.Exec(c, "insert into up_info_video(mid,account_type,account_state,signed_at) values(1115,1,3,'2018-05-30')")
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 20:02:03", 1101, 1115, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
s.dao.QueryRow(c, "select count(*) from av_income").Scan(&count)
|
|
So(count, ShouldEqual, 1)
|
|
s.dao.QueryRow(c, "select count(*) from up_income").Scan(&count)
|
|
So(count, ShouldEqual, 1)
|
|
s.dao.Exec(c, "delete from up_info_video where mid = 1115")
|
|
|
|
deleteAll(c)
|
|
s.dao.Exec(c, "delete from up_info_video where mid = 1115")
|
|
s.dao.Exec(c, "insert into up_info_video(mid,account_type,account_state,quit_at,signed_at) values(1115,1,5,'2018-06-01','2018-05-30')")
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 20:02:03", 1101, 1115, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
s.dao.QueryRow(c, "select count(*) from av_income").Scan(&count)
|
|
So(count, ShouldEqual, 0)
|
|
s.dao.QueryRow(c, "select count(*) from up_income").Scan(&count)
|
|
So(count, ShouldEqual, 0)
|
|
s.dao.Exec(c, "delete from up_info_video where mid = 1115")
|
|
|
|
deleteAll(c)
|
|
s.dao.Exec(c, "delete from up_info_video where mid = 1115")
|
|
s.dao.Exec(c, "insert into up_info_video(mid,account_type,account_state,quit_at,signed_at) values(1115,1,5,'2018-06-02','2018-05-30')")
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 20:02:03", 1101, 1115, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
s.dao.QueryRow(c, "select count(*) from av_income").Scan(&count)
|
|
So(count, ShouldEqual, 1)
|
|
s.dao.QueryRow(c, "select count(*) from up_income").Scan(&count)
|
|
So(count, ShouldEqual, 1)
|
|
s.dao.Exec(c, "delete from up_info_video where mid = 1115")
|
|
})
|
|
}
|
|
|
|
func Test_UpIncomeWeekAndMonthly(t *testing.T) {
|
|
Convey("Test up weekly and monthly income\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
ac1 := insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
ac2 := insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1102, 111, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
avIncome1 := checkAvIncome(c, ac1, 10, 0, 1, "2018-06-01")
|
|
avIncome2 := checkAvIncome(c, ac2, 10, 0, 1, "2018-06-01")
|
|
checkUpIncome(c, []*model.AvIncome{avIncome1}, 10, "up_income", "", 1)
|
|
checkUpIncome(c, []*model.AvIncome{avIncome2}, 10, "up_income", "", 1)
|
|
checkUpIncomeWeekly(c, []*model.AvIncome{avIncome1}, 10, 1)
|
|
checkUpIncomeMonthly(c, []*model.AvIncome{avIncome2}, 10, 1)
|
|
|
|
ac11 := insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
ac21 := insertAvDailyCharge(c, "2018-06-02", "2018-06-01 15:02:03", 1102, 111, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-02", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
avIncome11 := checkAvIncome(c, ac11, 20, 0, 1, "2018-06-02")
|
|
avIncome21 := checkAvIncome(c, ac21, 20, 0, 1, "2018-06-02")
|
|
checkUpIncome(c, []*model.AvIncome{avIncome11}, 20, "up_income", "", 1)
|
|
checkUpIncome(c, []*model.AvIncome{avIncome21}, 20, "up_income", "", 1)
|
|
checkUpIncomeWeekly(c, []*model.AvIncome{avIncome1, avIncome11}, 20, 1)
|
|
checkUpIncomeMonthly(c, []*model.AvIncome{avIncome2, avIncome21}, 20, 1)
|
|
|
|
ac12 := insertAvDailyCharge(c, "2018-06-05", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
ac22 := insertAvDailyCharge(c, "2018-06-05", "2018-06-01 15:02:03", 1102, 111, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-05", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
avIncome12 := checkAvIncome(c, ac12, 30, 0, 1, "2018-06-05")
|
|
avIncome22 := checkAvIncome(c, ac22, 30, 0, 1, "2018-06-05")
|
|
checkUpIncome(c, []*model.AvIncome{avIncome12}, 30, "up_income", "", 1)
|
|
checkUpIncome(c, []*model.AvIncome{avIncome22}, 30, "up_income", "", 1)
|
|
checkUpIncomeWeekly(c, []*model.AvIncome{avIncome12}, 30, 1)
|
|
checkUpIncomeMonthly(c, []*model.AvIncome{avIncome2, avIncome21, avIncome22}, 30, 1)
|
|
|
|
ac13 := insertAvDailyCharge(c, "2018-07-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
ac23 := insertAvDailyCharge(c, "2018-07-01", "2018-06-01 15:02:03", 1102, 111, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-07-01", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
err = s.runStatis(c, d)
|
|
So(err, ShouldBeNil)
|
|
avIncome13 := checkAvIncome(c, ac13, 40, 0, 1, "2018-07-01")
|
|
avIncome23 := checkAvIncome(c, ac23, 40, 0, 1, "2018-07-01")
|
|
checkUpIncome(c, []*model.AvIncome{avIncome13}, 40, "up_income", "", 1)
|
|
checkUpIncome(c, []*model.AvIncome{avIncome23}, 40, "up_income", "", 1)
|
|
checkUpIncomeWeekly(c, []*model.AvIncome{avIncome13}, 40, 1)
|
|
checkUpIncomeMonthly(c, []*model.AvIncome{avIncome23}, 40, 1)
|
|
})
|
|
}
|
|
|
|
func Test_UpAccount(t *testing.T) {
|
|
Convey("Test up_account\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
insertAvDailyCharge(c, "2018-06-30", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-30", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-30", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpAccount(c, 110, 20, 20, 0, "2018-05")
|
|
|
|
insertAvDailyCharge(c, "2018-07-01", "2018-06-01 15:02:03", 1103, 110, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-07-01", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpAccount(c, 110, 30, 20, 0, "2018-05")
|
|
|
|
insertAvDailyCharge(c, "2018-07-02", "2018-06-01 15:02:03", 1101, 110, 50)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-07-02", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpAccount(c, 110, 80, 20, 0, "2018-05")
|
|
|
|
s.dao.Exec(c, "update up_account set total_unwithdraw_income = 60, total_withdraw_income = 20, withdraw_date_version = '2018-06' where mid = 110")
|
|
insertAvDailyCharge(c, "2018-07-03", "2018-06-01 15:02:03", 1101, 110, 50)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-07-03", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpAccount(c, 110, 130, 110, 20, "2018-06")
|
|
})
|
|
}
|
|
|
|
func Test_MuchUpAccount(t *testing.T) {
|
|
Convey("Test much up account\n", t, func() {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1102, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1103, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1104, 111, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1105, 111, 10)
|
|
insertAvDailyCharge(c, "2018-06-01", "2018-06-01 15:02:03", 1106, 112, 10)
|
|
d, _ := time.ParseInLocation("2006-01-02", "2018-06-01", time.Local)
|
|
err := s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpAccount(c, 110, 30, 30, 0, "2018-05")
|
|
checkUpAccount(c, 111, 20, 20, 0, "2018-05")
|
|
checkUpAccount(c, 112, 10, 10, 0, "2018-05")
|
|
|
|
insertAvDailyCharge(c, "2018-06-03", "2018-06-01 15:02:03", 1101, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-03", "2018-06-01 15:02:03", 1103, 110, 10)
|
|
insertAvDailyCharge(c, "2018-06-03", "2018-06-01 15:02:03", 1104, 111, 10)
|
|
insertAvDailyCharge(c, "2018-06-03", "2018-06-01 15:02:03", 1105, 111, 10)
|
|
insertAvDailyCharge(c, "2018-06-03", "2018-06-01 15:02:03", 1106, 112, 10)
|
|
insertAvDailyCharge(c, "2018-06-03", "2018-06-01 15:02:03", 1107, 112, 10)
|
|
d, _ = time.ParseInLocation("2006-01-02", "2018-06-03", time.Local)
|
|
err = s.run(c, d)
|
|
So(err, ShouldBeNil)
|
|
checkUpAccount(c, 110, 50, 50, 0, "2018-05")
|
|
checkUpAccount(c, 111, 40, 40, 0, "2018-05")
|
|
checkUpAccount(c, 112, 30, 30, 0, "2018-05")
|
|
})
|
|
}
|
|
|
|
func checkAllData(c context.Context, ac *model.AvCharge, totalIncome, taxMoney, count int64, date string) {
|
|
d, _ := time.ParseInLocation(_layout, date, time.Local)
|
|
// av
|
|
avIncome := checkAvIncome(c, ac, totalIncome, taxMoney, count, date)
|
|
checkAvIncomeStatis(c, avIncome, totalIncome) // Background
|
|
checkAvIncomeDateStatis(c, int(0), int(1), int(ac.TagID), int(totalIncome), int(12), d, "av_income_daily_statis")
|
|
weekD := getStartWeeklyDate(d)
|
|
checkAvIncomeDateStatis(c, int(0), int(1), int(ac.TagID), int(totalIncome), int(12), weekD, "av_income_weekly_statis")
|
|
monthD := getStartMonthlyDate(d)
|
|
checkAvIncomeDateStatis(c, int(0), int(1), int(ac.TagID), int(totalIncome), int(12), monthD, "av_income_monthly_statis")
|
|
|
|
// up
|
|
up := checkUpIncome(c, []*model.AvIncome{avIncome}, avIncome.Income, "up_income", "", 1)
|
|
checkUpIncomeWeekly(c, []*model.AvIncome{avIncome}, avIncome.Income, 1)
|
|
checkUpIncomeMonthly(c, []*model.AvIncome{avIncome}, avIncome.Income, 1)
|
|
checkUpIncomeStatis(c, up.MID, avIncome.Income)
|
|
checkUpIncomeDailyStatis(c, 0, 1, avIncome.Income, d)
|
|
checkUpAccount(c, up.MID, avIncome.Income, avIncome.Income, 0, "2018-05")
|
|
}
|
|
|
|
func checkAvIncome(c context.Context, ac *model.AvCharge, totalIncome, taxMoney, count int64, date string) *model.AvIncome {
|
|
ai := &model.AvIncome{}
|
|
err := s.dao.QueryRow(c, fmt.Sprintf("select av_id,mid,tag_id,is_original,upload_time,play_count,total_income,income,tax_money,date from av_income where av_id = %d and date = '%s'", ac.AvID, date)).Scan(
|
|
&ai.AvID, &ai.MID, &ai.TagID, &ai.IsOriginal, &ai.UploadTime, &ai.PlayCount, &ai.TotalIncome, &ai.Income, &ai.TaxMoney, &ai.Date)
|
|
So(err, ShouldBeNil)
|
|
So(ac.AvID, ShouldEqual, ai.AvID)
|
|
So(ac.MID, ShouldEqual, ai.MID)
|
|
So(ac.TagID, ShouldEqual, ai.TagID)
|
|
So(ac.IsOriginal, ShouldEqual, ai.IsOriginal)
|
|
So(ac.UploadTime, ShouldEqual, ai.UploadTime)
|
|
So(ac.TotalPlayCount, ShouldEqual, ai.PlayCount)
|
|
So(totalIncome, ShouldEqual, ai.TotalIncome)
|
|
So(taxMoney, ShouldEqual, ai.TaxMoney)
|
|
So(ac.IncCharge, ShouldEqual, ai.Income)
|
|
So(ac.Date, ShouldEqual, ai.Date)
|
|
return ai
|
|
}
|
|
|
|
func checkAvIncomeTag(c context.Context, avID, income, taxMoney, totalIncome int64, date string) {
|
|
ai := &model.AvIncome{}
|
|
err := s.dao.QueryRow(c, fmt.Sprintf("select total_income,income,tax_money from av_income where av_id = %d and date = '%s'", avID, date)).Scan(
|
|
&ai.TotalIncome, &ai.Income, &ai.TaxMoney)
|
|
So(err, ShouldBeNil)
|
|
So(totalIncome, ShouldEqual, ai.TotalIncome)
|
|
So(taxMoney, ShouldEqual, ai.TaxMoney)
|
|
So(income, ShouldEqual, ai.Income)
|
|
}
|
|
|
|
func checkAvIncomeStatis(c context.Context, ac *model.AvIncome, totalIncome int64) {
|
|
ai := &model.AvIncomeStat{}
|
|
err := s.dao.QueryRow(c, fmt.Sprintf("select av_id,mid,tag_id,is_original,upload_time,total_income from av_income_statis where av_id = %d", ac.AvID)).Scan(
|
|
&ai.AvID, &ai.MID, &ai.TagID, &ai.IsOriginal, &ai.UploadTime, &ai.TotalIncome)
|
|
So(err, ShouldBeNil)
|
|
So(ac.AvID, ShouldEqual, ai.AvID)
|
|
So(ac.MID, ShouldEqual, ai.MID)
|
|
So(ac.TagID, ShouldEqual, ai.TagID)
|
|
So(ac.IsOriginal, ShouldEqual, ai.IsOriginal)
|
|
So(ac.UploadTime, ShouldEqual, ai.UploadTime)
|
|
So(ac.TotalIncome, ShouldEqual, ai.TotalIncome)
|
|
}
|
|
|
|
func checkAvIncomeDateStatis(c context.Context, section, avs, categoryID, income, count int, d time.Time, table string) {
|
|
xd := xtime.Time(d.Unix())
|
|
ads := &model.DateStatis{}
|
|
err := s.dao.QueryRow(c, fmt.Sprintf("select avs,income,cdate from %s where money_section = %d and category_id = %d and cdate = '%s'", table, section, categoryID, d.Format(_layout))).Scan(
|
|
&ads.Count, &ads.Income, &ads.CDate)
|
|
So(err, ShouldBeNil)
|
|
So(income, ShouldEqual, ads.Income)
|
|
So(xd, ShouldEqual, ads.CDate)
|
|
So(avs, ShouldEqual, ads.Count)
|
|
var ccount int64
|
|
err = s.dao.QueryRow(c, fmt.Sprintf("select count(*) from %s where category_id = %d and cdate = '%s'", table, categoryID, d.Format(_layout))).Scan(&ccount)
|
|
So(err, ShouldBeNil)
|
|
So(count, ShouldEqual, ccount)
|
|
}
|
|
|
|
func checkUpIncome(c context.Context, avs []*model.AvIncome, totalIncome int64, table string, date string, count int64) (up *model.UpIncome) {
|
|
if len(avs) == 0 {
|
|
return
|
|
}
|
|
mid := avs[0].MID
|
|
if date == "" {
|
|
date = avs[0].Date.Time().Format(_layout)
|
|
}
|
|
var playCount, avIncome, taxMoney int64
|
|
for _, av := range avs {
|
|
playCount += av.PlayCount
|
|
avIncome += av.Income
|
|
taxMoney += av.TaxMoney
|
|
}
|
|
|
|
up = &model.UpIncome{}
|
|
err := s.dao.QueryRow(c, fmt.Sprintf("select mid,av_count,play_count,av_income,audio_income,column_income,tax_money,income,total_income from %s where mid = %d and date = '%s'", table, mid, date)).Scan(
|
|
&up.MID, &up.AvCount, &up.PlayCount, &up.AvIncome, &up.AudioIncome, &up.ColumnIncome, &up.TaxMoney, &up.Income, &up.TotalIncome)
|
|
So(err, ShouldBeNil)
|
|
So(count, ShouldEqual, up.AvCount)
|
|
// So(playCount, ShouldEqual, up.PlayCount)
|
|
So(avIncome, ShouldEqual, up.AvIncome)
|
|
So(0, ShouldEqual, up.AudioIncome)
|
|
So(0, ShouldEqual, up.ColumnIncome)
|
|
So(taxMoney, ShouldEqual, up.TaxMoney)
|
|
So(totalIncome, ShouldEqual, up.TotalIncome)
|
|
return up
|
|
}
|
|
|
|
func checkUpIncomeTag(c context.Context, mid, income, taxMoney, totalIncome int64, date, table string) {
|
|
up := &model.UpIncome{}
|
|
err := s.dao.QueryRow(c, fmt.Sprintf("select tax_money,income,total_income from %s where mid = %d and date = '%s'", table, mid, date)).Scan(
|
|
&up.TaxMoney, &up.Income, &up.TotalIncome)
|
|
So(err, ShouldBeNil)
|
|
So(income, ShouldEqual, up.Income)
|
|
So(taxMoney, ShouldEqual, up.TaxMoney)
|
|
So(totalIncome, ShouldEqual, up.TotalIncome)
|
|
}
|
|
|
|
func checkUpIncomeWeekly(c context.Context, avs []*model.AvIncome, totalIncome, count int64) {
|
|
m := make(map[string][]*model.AvIncome)
|
|
for _, av := range avs {
|
|
d := getStartWeeklyDate(av.Date.Time()).Format(_layout)
|
|
if _, ok := m[d]; !ok {
|
|
m[d] = make([]*model.AvIncome, 0)
|
|
}
|
|
m[d] = append(m[d], av)
|
|
}
|
|
for date, avs := range m {
|
|
checkUpIncome(c, avs, totalIncome, "up_income_weekly", date, count)
|
|
}
|
|
}
|
|
|
|
func checkUpIncomeMonthly(c context.Context, avs []*model.AvIncome, totalIncome, count int64) {
|
|
m := make(map[string][]*model.AvIncome)
|
|
for _, av := range avs {
|
|
d := getStartMonthlyDate(av.Date.Time()).Format(_layout)
|
|
if _, ok := m[d]; !ok {
|
|
m[d] = make([]*model.AvIncome, 0)
|
|
}
|
|
m[d] = append(m[d], av)
|
|
}
|
|
for date, avs := range m {
|
|
checkUpIncome(c, avs, totalIncome, "up_income_monthly", date, count)
|
|
}
|
|
}
|
|
|
|
func checkUpIncomeStatis(c context.Context, mid, totalIncome int64) {
|
|
var income int64
|
|
err := s.dao.QueryRow(c, fmt.Sprintf("select total_income from up_income_statis where mid = %d", mid)).Scan(&income)
|
|
So(err, ShouldBeNil)
|
|
So(totalIncome, ShouldEqual, income)
|
|
}
|
|
|
|
func checkUpIncomeDailyStatis(c context.Context, section, ups, income int64, d time.Time) {
|
|
xd := xtime.Time(d.Unix())
|
|
ads := &model.DateStatis{}
|
|
err := s.dao.QueryRow(c, fmt.Sprintf("select ups,income,cdate from up_income_daily_statis where money_section = %d and cdate = '%s'", section, d.Format(_layout))).Scan(
|
|
&ads.Count, &ads.Income, &ads.CDate)
|
|
So(err, ShouldBeNil)
|
|
So(income, ShouldEqual, ads.Income)
|
|
So(xd, ShouldEqual, ads.CDate)
|
|
So(ups, ShouldEqual, ads.Count)
|
|
var ccount int64
|
|
err = s.dao.QueryRow(c, fmt.Sprintf("select count(*) from up_income_daily_statis where cdate = '%s'", d.Format(_layout))).Scan(&ccount)
|
|
So(err, ShouldBeNil)
|
|
So(12, ShouldEqual, ccount)
|
|
}
|
|
|
|
func checkUpAccount(c context.Context, mid, total, unwithdraw, withdraw int64, dateVersion string) {
|
|
up := &model.UpAccount{}
|
|
err := s.dao.QueryRow(c, fmt.Sprintf("select total_income,total_unwithdraw_income,total_withdraw_income,withdraw_date_version from up_account where mid = %d", mid)).Scan(
|
|
&up.TotalIncome, &up.TotalUnwithdrawIncome, &up.TotalWithdrawIncome, &up.WithdrawDateVersion)
|
|
So(err, ShouldBeNil)
|
|
So(up.TotalIncome, ShouldEqual, total)
|
|
So(up.TotalUnwithdrawIncome, ShouldEqual, unwithdraw)
|
|
So(up.TotalWithdrawIncome, ShouldEqual, withdraw)
|
|
So(up.WithdrawDateVersion, ShouldEqual, dateVersion)
|
|
}
|
|
|
|
// func prepareTest(c context.Context) {
|
|
// s.dao.Exec(c, "delete from av_daily_charge_06")
|
|
// s.dao.Exec(c, "delete from av_daily_charge_07")
|
|
// s.dao.Exec(c, "delete from av_income where av_id = 1101")
|
|
// s.dao.Exec(c, "delete from av_income_statis where av_id = 1101")
|
|
// s.dao.Exec(c, "delete from av_income_daily_statis")
|
|
// s.dao.Exec(c, "delete from av_income_weekly_statis")
|
|
// s.dao.Exec(c, "delete from av_income_monthly_statis")
|
|
// s.dao.Exec(c, "delete from av_weekly_charge where av_id = 1101")
|
|
// s.dao.Exec(c, "delete from av_monthly_charge where av_id = 1101")
|
|
// s.dao.Exec(c, "delete from av_charge_statis where av_id = 1101")
|
|
// s.dao.Exec(c, "delete from up_income where mid = 110")
|
|
// s.dao.Exec(c, "delete from up_income_weekly where mid = 110")
|
|
// s.dao.Exec(c, "delete from up_income_monthly where mid = 110")
|
|
// s.dao.Exec(c, "delete from up_income_statis where mid = 110")
|
|
// s.dao.Exec(c, "delete from up_income_daily_statis")
|
|
// s.dao.Exec(c, "delete from up_account where mid = 110")
|
|
// s.dao.Exec(c, "delete from up_daily_charge where mid = 110")
|
|
// s.dao.Exec(c, "delete from up_weekly_charge where mid = 110")
|
|
// s.dao.Exec(c, "delete from up_monthly_charge where mid = 110")
|
|
// s.dao.Exec(c, "delete from up_av_statis where mid = 110")
|
|
// }
|
|
|
|
func deleteAll(c context.Context) {
|
|
// s.dao.Exec(c, "truncate up_info_video")
|
|
// s.dao.Exec(c, "truncate av_daily_charge_07")
|
|
// s.dao.Exec(c, "truncate av_daily_charge_06")
|
|
s.dao.Exec(c, "truncate av_black_list")
|
|
s.dao.Exec(c, "truncate av_charge_ratio")
|
|
s.dao.Exec(c, "truncate up_charge_ratio")
|
|
s.dao.Exec(c, "truncate av_income")
|
|
s.dao.Exec(c, "truncate av_income_statis")
|
|
s.dao.Exec(c, "truncate av_income_daily_statis")
|
|
s.dao.Exec(c, "truncate av_income_weekly_statis")
|
|
s.dao.Exec(c, "truncate av_income_monthly_statis")
|
|
s.dao.Exec(c, "truncate up_income")
|
|
s.dao.Exec(c, "truncate up_income_weekly")
|
|
s.dao.Exec(c, "truncate up_income_monthly")
|
|
s.dao.Exec(c, "truncate up_income_statis")
|
|
s.dao.Exec(c, "truncate up_income_daily_statis")
|
|
s.dao.Exec(c, "truncate up_account")
|
|
s.dao.Exec(c, "truncate up_av_daily_statis")
|
|
s.dao.Exec(c, "truncate up_column_daily_statis")
|
|
s.dao.Exec(c, "truncate column_income_daily_statis")
|
|
s.dao.Exec(c, "truncate column_income_weekly_statis")
|
|
s.dao.Exec(c, "truncate column_income_monthly_statis")
|
|
|
|
// s.dao.Exec(c, "truncate up_info_column")
|
|
s.dao.Exec(c, "truncate column_income")
|
|
s.dao.Exec(c, "truncate column_income_statis")
|
|
}
|
|
|
|
func getAvDailyChargeStruct(date string, uploadDate string, avID, mid, charge int64) *model.AvCharge {
|
|
d, _ := time.ParseInLocation(_layout, date, time.Local)
|
|
upD, _ := time.ParseInLocation(_layoutSec, uploadDate, time.Local)
|
|
ac := &model.AvCharge{
|
|
AvID: avID,
|
|
MID: mid,
|
|
TagID: 1,
|
|
IsOriginal: 1,
|
|
DanmakuCount: charge,
|
|
CommentCount: charge,
|
|
CollectCount: charge,
|
|
CoinCount: charge,
|
|
ShareCount: charge,
|
|
ElecPayCount: charge,
|
|
TotalPlayCount: charge * int64(3),
|
|
WebPlayCount: charge,
|
|
AppPlayCount: charge,
|
|
H5PlayCount: charge,
|
|
LvUnknown: charge,
|
|
Lv0: charge,
|
|
Lv1: charge,
|
|
Lv2: charge,
|
|
Lv3: charge,
|
|
Lv4: charge,
|
|
Lv5: charge,
|
|
Lv6: charge,
|
|
VScore: charge,
|
|
IncCharge: charge,
|
|
TotalCharge: 0,
|
|
Date: xtime.Time(d.Unix()),
|
|
UploadTime: xtime.Time(upD.Unix()),
|
|
DBState: _dbInsert,
|
|
}
|
|
return ac
|
|
}
|
|
|
|
func getColumnDailyChargeStruct(date string, uploadDate string, aid, mid, charge int64) *model.ColumnCharge {
|
|
d, _ := time.ParseInLocation(_layout, date, time.Local)
|
|
upD, _ := time.ParseInLocation(_layoutSec, uploadDate, time.Local)
|
|
cc := &model.ColumnCharge{
|
|
ArticleID: aid,
|
|
Title: "sssss",
|
|
MID: mid,
|
|
TagID: 1,
|
|
IncCharge: charge,
|
|
IncViewCount: 10,
|
|
Date: xtime.Time(d.Unix()),
|
|
UploadTime: xtime.Time(upD.Unix()),
|
|
}
|
|
return cc
|
|
}
|
|
|
|
func insertAvDailyCharge(c context.Context, date string, uploadDate string, avID, mid, charge int64) *model.AvCharge {
|
|
s.dao.Exec(c, fmt.Sprintf("insert into task_status(type,date,status) values(1,'%s',1) on duplicate key update date=values(date)", date))
|
|
ac := getAvDailyChargeStruct(date, uploadDate, avID, mid, charge)
|
|
_, err := s.avCharge.avChargeBatchInsert(c, []*model.AvCharge{ac}, fmt.Sprintf("av_daily_charge_%s", strings.Split(date, "-")[1]))
|
|
So(err, ShouldBeNil)
|
|
return ac
|
|
}
|
|
|
|
func insertBubbleMeta(c context.Context, values string) {
|
|
s.dao.Exec(c, fmt.Sprintf("insert into lottery_av_info(av_id,b_type,date) values %s on duplicate key update b_type=values(b_type) date=values(date)", values))
|
|
}
|
|
|
|
func insertAvDailyChargeBatch(c context.Context, date string, acs []*model.AvCharge) {
|
|
s.avCharge.avChargeBatchInsert(c, acs, fmt.Sprintf("av_daily_charge_%s", strings.Split(date, "-")[1]))
|
|
}
|
|
|
|
func insertColumnDailyChargeBatch(c context.Context, date string, acs []*model.ColumnCharge) {
|
|
s.avCharge.columnChargeBatchInsert(c, acs, "column_daily_charge")
|
|
}
|
|
|
|
func batchInsertUpInfoVideo(c context.Context, mids []int64) {
|
|
var buf bytes.Buffer
|
|
for _, mid := range mids {
|
|
buf.WriteString("(")
|
|
buf.WriteString(strconv.FormatInt(mid, 10))
|
|
buf.WriteByte(',')
|
|
buf.WriteString("1")
|
|
buf.WriteByte(',')
|
|
buf.WriteString("3")
|
|
buf.WriteString(")")
|
|
buf.WriteByte(',')
|
|
}
|
|
if buf.Len() > 0 {
|
|
buf.Truncate(buf.Len() - 1)
|
|
}
|
|
values := buf.String()
|
|
buf.Reset()
|
|
s.dao.Exec(c, "delete from up_info_video")
|
|
s.dao.Exec(c, "delete from up_info_column")
|
|
s.dao.Exec(c, fmt.Sprintf("insert into up_info_video(mid,account_type,account_state) values %s", values))
|
|
s.dao.Exec(c, fmt.Sprintf("insert into up_info_column(mid,account_type,account_state) values %s", values))
|
|
}
|
|
|
|
// test 2018-09
|
|
func BenchmarkRunOneDay(b *testing.B) {
|
|
c := context.Background()
|
|
deleteAll(c)
|
|
date := "2018-09-02"
|
|
s.dao.Exec(c, "truncate av_daily_charge_09")
|
|
s.dao.Exec(c, "truncate column_daily_charge")
|
|
uploadDate := "2018-09-01 21:20:30"
|
|
acs := make([]*model.AvCharge, 20000)
|
|
ccs := make([]*model.ColumnCharge, 20000)
|
|
j := 0
|
|
for i := 1; i <= 1000000; i++ {
|
|
if j >= 20000 {
|
|
insertAvDailyChargeBatch(c, date, acs)
|
|
insertColumnDailyChargeBatch(c, date, ccs)
|
|
j = 0
|
|
}
|
|
acs[j] = getAvDailyChargeStruct(date, uploadDate, int64(i), int64(j+1), 100)
|
|
ccs[j] = getColumnDailyChargeStruct(date, uploadDate, int64(i), int64(j+1), 100)
|
|
j++
|
|
}
|
|
if j > 0 {
|
|
insertAvDailyChargeBatch(c, date, acs[:j])
|
|
insertColumnDailyChargeBatch(c, date, ccs[:j])
|
|
}
|
|
|
|
mids := make([]int64, 20000)
|
|
for i := 1; i <= 20000; i++ {
|
|
mids[i-1] = int64(i)
|
|
}
|
|
batchInsertUpInfoVideo(c, mids)
|
|
fmt.Println("start run...........")
|
|
d, _ := time.ParseInLocation("2006-01-02", date, time.Local)
|
|
for n := 0; n < b.N; n++ {
|
|
s.run(c, d)
|
|
}
|
|
}
|