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.
1025 lines
43 KiB
1025 lines
43 KiB
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) |
|
} |
|
}
|
|
|