Create & Init Project...

app/admin/main/growup/service/income/BUILD

@@ -0,0 +1,80 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "archive_income_test.go",
+        "av_breach_test.go",
+        "blacklist_test.go",
+        "service_test.go",
+        "up_account_test.go",
+        "up_category_info_test.go",
+        "up_income_test.go",
+        "up_info_video_test.go",
+        "withdraw_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/growup/conf:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "archive_income.go",
+        "av_breach.go",
+        "blacklist.go",
+        "charge.go",
+        "const.go",
+        "format.go",
+        "lottery.go",
+        "service.go",
+        "up_account.go",
+        "up_category_info.go",
+        "up_income.go",
+        "up_info_video.go",
+        "withdraw.go",
+    ],
+    importpath = "go-common/app/admin/main/growup/service/income",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/growup/conf:go_default_library",
+        "//app/admin/main/growup/dao:go_default_library",
+        "//app/admin/main/growup/dao/income:go_default_library",
+        "//app/admin/main/growup/dao/message:go_default_library",
+        "//app/admin/main/growup/dao/resource:go_default_library",
+        "//app/admin/main/growup/model:go_default_library",
+        "//app/admin/main/growup/model/income:go_default_library",
+        "//app/admin/main/growup/service:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/time:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/golang.org/x/sync/errgroup:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/growup/service/income/archive_income.go

@@ -0,0 +1,380 @@
+package income
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"strconv"
+	"time"
+
+	model "go-common/app/admin/main/growup/model/income"
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+// ArchiveStatis archive income statis
+func (s *Service) ArchiveStatis(c context.Context, categoryID []int64, typ, groupType int, fromTime, toTime int64) (data interface{}, err error) {
+	table := setArchiveTableByGroup(typ, groupType)
+	from := getDateByGroup(groupType, time.Unix(fromTime, 0))
+	to := getDateByGroup(groupType, time.Unix(toTime, 0))
+	query := formatArchiveQuery(categoryID, from, to)
+
+	if typ == _lottery {
+		data, err = s.lotteryStatis(c, categoryID, from, addDayByGroup(groupType, to).AddDate(0, 0, -1), groupType)
+		if err != nil {
+			log.Error("s.lotteryStatis error(%v)", err)
+		}
+		return
+	}
+	avs, err := s.GetArchiveStatis(c, table, query)
+	if err != nil {
+		log.Error("s.GetArchiveStatis error(%v)", err)
+		return
+	}
+
+	data = archiveStatis(avs, from, to, groupType)
+	return
+}
+
+func archiveStatis(avs []*model.ArchiveStatis, from, to time.Time, groupType int) interface{} {
+	avsMap := make(map[string]*model.ArchiveStatis)
+	ctgyMap := make(map[string]bool)
+	for _, av := range avs {
+		date := formatDateByGroup(av.CDate.Time(), groupType)
+		ctgykey := date + strconv.FormatInt(av.CategroyID, 10)
+		if val, ok := avsMap[date]; ok {
+			val.Avs += av.Avs
+			if !ctgyMap[ctgykey] {
+				val.Income += av.Income
+				ctgyMap[ctgykey] = true
+			}
+		} else {
+			avsMap[date] = &model.ArchiveStatis{
+				Avs:    av.Avs,
+				Income: av.Income,
+			}
+			ctgyMap[ctgykey] = true
+		}
+	}
+	return parseArchiveStatis(avsMap, from, to, groupType)
+}
+
+func parseArchiveStatis(avsMap map[string]*model.ArchiveStatis, from, to time.Time, groupType int) interface{} {
+	income, counts, xAxis := []string{}, []int64{}, []string{}
+	// get result by date
+	to = to.AddDate(0, 0, 1)
+	for from.Before(to) {
+		dateStr := formatDateByGroup(from, groupType)
+		xAxis = append(xAxis, dateStr)
+		if val, ok := avsMap[dateStr]; ok {
+			income = append(income, fmt.Sprintf("%.2f", float64(val.Income)/float64(100)))
+			counts = append(counts, val.Avs)
+		} else {
+			income = append(income, "0")
+			counts = append(counts, int64(0))
+		}
+		from = addDayByGroup(groupType, from)
+	}
+
+	return map[string]interface{}{
+		"counts":  counts,
+		"incomes": income,
+		"xaxis":   xAxis,
+	}
+}
+
+// ArchiveSection get av/column income section
+func (s *Service) ArchiveSection(c context.Context, categoryID []int64, typ, groupType int, fromTime, toTime int64) (data interface{}, err error) {
+	table := setArchiveTableByGroup(typ, groupType)
+	from := getDateByGroup(groupType, time.Unix(fromTime, 0))
+	to := getDateByGroup(groupType, time.Unix(toTime, 0))
+	query := formatArchiveQuery(categoryID, from, to)
+
+	avs, err := s.GetArchiveStatis(c, table, query)
+	if err != nil {
+		log.Error("s.GetArchiveStatis error(%v)", err)
+		return
+	}
+	data = archiveSection(avs, from, to, groupType)
+	return
+}
+
+func archiveSection(avs []*model.ArchiveStatis, from, to time.Time, groupType int) interface{} {
+	ret := make([]map[string]interface{}, 0)
+	avsMap := make(map[string][]int64)
+	for _, av := range avs {
+		date := formatDateByGroup(av.CDate.Time(), groupType)
+		if val, ok := avsMap[date]; ok {
+			val[av.MoneySection] += av.Avs
+		} else {
+			avsMap[date] = make([]int64, 12)
+			avsMap[date][av.MoneySection] = av.Avs
+			ret = append(ret, map[string]interface{}{
+				"date_format": date,
+				"sections":    avsMap[date],
+			})
+		}
+	}
+	return ret
+}
+
+// ArchiveDetail archive detail (av column)
+func (s *Service) ArchiveDetail(c context.Context, mid int64, typ, groupType int, fromTime, toTime int64) (archives []*model.ArchiveIncome, err error) {
+	archives = make([]*model.ArchiveIncome, 0)
+	from := getDateByGroup(groupType, time.Unix(fromTime, 0))
+	to := getDateByGroup(groupType, time.Unix(toTime, 0))
+	to = addDayByGroup(groupType, to).AddDate(0, 0, -1)
+	if typ == _video || typ == _up {
+		var avs []*model.ArchiveIncome
+		avs, err = s.archiveDetail(c, _video, groupType, mid, from, to)
+		if err != nil {
+			log.Error("s.archiveDetail error(%v)", err)
+			return
+		}
+		archives = append(archives, avs...)
+	}
+
+	if typ == _column || typ == _up {
+		var columns []*model.ArchiveIncome
+		columns, err = s.archiveDetail(c, _column, groupType, mid, from, to)
+		if err != nil {
+			log.Error("s.archiveDetail error(%v)", err)
+			return
+		}
+		archives = append(archives, columns...)
+	}
+
+	if typ == _bgm || typ == _up {
+		var bgms []*model.ArchiveIncome
+		bgms, err = s.archiveDetail(c, _bgm, groupType, mid, from, to)
+		if err != nil {
+			log.Error("s.archiveDetail error(%v)", err)
+			return
+		}
+		archives = append(archives, bgms...)
+	}
+	return
+}
+
+func (s *Service) archiveDetail(c context.Context, typ, groupType int, mid int64, from, to time.Time) (archives []*model.ArchiveIncome, err error) {
+	archives = make([]*model.ArchiveIncome, 0)
+	query := fmt.Sprintf("mid = %d", mid)
+	origins, err := s.GetArchiveIncome(c, typ, query, from.Format(_layout), to.Format(_layout))
+	if err != nil {
+		log.Error("s.GetArchiveIncome error(%v)", err)
+		return
+	}
+
+	var black map[int64]struct{}
+	black, err = s.dao.GetAvBlackListByMID(c, mid, typ)
+	if err != nil {
+		log.Error("s.dao.GetAvBlackListByMID error(%v)", err)
+		return
+	}
+	archives = calArchiveDetail(origins, black, groupType)
+	return
+}
+
+func calArchiveDetail(archives []*model.ArchiveIncome, blackMap map[int64]struct{}, groupType int) []*model.ArchiveIncome {
+	avsMap := make(map[string]*model.ArchiveIncome)
+	for _, av := range archives {
+		if _, ok := blackMap[av.AvID]; ok {
+			continue
+		}
+		date := formatDateByGroup(av.Date.Time(), groupType)
+		key := date + strconv.FormatInt(av.AvID, 10)
+		if val, ok := avsMap[key]; ok {
+			val.Income += av.Income
+		} else {
+			av.DateFormat = date
+			avsMap[key] = av
+		}
+	}
+	list := make([]*model.ArchiveIncome, 0)
+	for _, av := range avsMap {
+		list = append(list, av)
+	}
+
+	sort.Slice(list, func(i, j int) bool {
+		if list[i].DateFormat == list[j].DateFormat {
+			return list[i].Income > list[j].Income
+		}
+		return list[i].DateFormat > list[j].DateFormat
+	})
+	return list
+}
+
+// ArchiveTop archive_income top
+func (s *Service) ArchiveTop(c context.Context, aIDs []int64, typ int, groupType int, fromTime, toTime int64, from, limit int) (data []*model.ArchiveIncome, total int, err error) {
+	query := ""
+	if len(aIDs) != 0 {
+		switch typ {
+		case _video, _lottery:
+			query = fmt.Sprintf("av_id IN (%s)", xstr.JoinInts(aIDs))
+		case _column:
+			query = fmt.Sprintf("aid IN (%s)", xstr.JoinInts(aIDs))
+		case _bgm:
+			query = fmt.Sprintf("sid IN (%s)", xstr.JoinInts(aIDs))
+		}
+	}
+	if query == "" && typ != _lottery {
+		query = fmt.Sprintf("income >= %d", _leastAvIncome)
+	}
+	avs, err := s.GetArchiveIncome(c, typ, query, time.Unix(fromTime, 0).Format(_layout), time.Unix(toTime, 0).Format(_layout))
+	if err != nil {
+		log.Error("s.GetArchiveIncome error(%v)", err)
+		return
+	}
+	if typ == _lottery {
+		typ = _video
+	}
+	avBMap, err := s.GetAvBlackListByAvIds(c, avs, typ)
+	if err != nil {
+		log.Error("s.GetAvBlackListByAvIds error(%v)", err)
+		return
+	}
+	data, total = archiveTop(avs, avBMap, from, limit)
+
+	upInfo, err := s.GetUpInfoByAIDs(c, data)
+	if err != nil {
+		log.Error("s.GetUpInfoByAIDs error(%v)", err)
+		return
+	}
+
+	for i := 0; i < len(data); i++ {
+		data[i].Nickname = upInfo[data[i].MID]
+	}
+	return
+}
+
+func archiveTop(avs []*model.ArchiveIncome, avBlack map[int64]struct{}, from, limit int) ([]*model.ArchiveIncome, int) {
+	nAvs := make([]*model.ArchiveIncome, 0)
+	for _, av := range avs {
+		if _, ok := avBlack[av.AvID]; ok {
+			continue
+		}
+		av.DateFormat = av.Date.Time().Format(_layout)
+		nAvs = append(nAvs, av)
+	}
+	sort.Slice(nAvs, func(i, j int) bool {
+		if nAvs[i].Date == nAvs[j].Date {
+			return nAvs[i].Income > nAvs[j].Income
+		}
+		return nAvs[i].Date > nAvs[j].Date
+	})
+
+	if limit+from > len(nAvs) {
+		limit = len(nAvs)
+	}
+	total := len(nAvs)
+	return nAvs[from:limit], total
+}
+
+// BgmDetail bgm detail
+func (s *Service) BgmDetail(c context.Context, sid int64, fromTime, toTime int64, from, limit int) (avs []*model.ArchiveIncome, total int, err error) {
+	avs = make([]*model.ArchiveIncome, 0)
+	fromDate := time.Unix(fromTime, 0).Format(_layout)
+	toDate := time.Unix(toTime, 0).Format(_layout)
+	avMap, err := s.dao.GetAvByBgm(c, sid, fromDate, toDate)
+	if err != nil {
+		log.Error("s.dao.GetAvByBgm error(%v)", err)
+		return
+	}
+	if len(avMap) == 0 {
+		return
+	}
+	avIDs := make([]int64, 0, len(avMap))
+	for avID := range avMap {
+		avIDs = append(avIDs, avID)
+	}
+	avs, err = s.GetArchiveIncome(c, _video, fmt.Sprintf("av_id in (%s)", xstr.JoinInts(avIDs)), fromDate, toDate)
+	if err != nil {
+		log.Error("s.GetArchiveIncome error(%v)", err)
+		return
+	}
+	if limit > len(avs) {
+		limit = len(avs)
+	}
+	total = len(avs)
+	avs = avs[from:limit]
+	return
+}
+
+// GetArchiveStatis get up income
+func (s *Service) GetArchiveStatis(c context.Context, table, query string) (avs []*model.ArchiveStatis, err error) {
+	offset, size := 0, 2000
+	for {
+		av, err := s.dao.GetArchiveStatis(c, table, query, offset, size)
+		if err != nil {
+			return nil, err
+		}
+		avs = append(avs, av...)
+		if len(av) < size {
+			break
+		}
+		offset += len(av)
+	}
+	return
+}
+
+// GetArchiveIncome get archive income
+func (s *Service) GetArchiveIncome(c context.Context, typ int, query string, from, to string) (archs []*model.ArchiveIncome, err error) {
+	var id int64
+	limit := 2000
+	for {
+		var arch []*model.ArchiveIncome
+		arch, err = s.dao.GetArchiveIncome(c, id, query, from, to, limit, typ)
+		if err != nil {
+			return
+		}
+		archs = append(archs, arch...)
+		if len(arch) < limit {
+			break
+		}
+		id = arch[len(arch)-1].ID
+	}
+	if typ == _bgm {
+		bgms := make(map[string]*model.ArchiveIncome)
+		for _, bgm := range archs {
+			key := bgm.Date.Time().Format(_layout) + strconv.FormatInt(bgm.AvID, 10)
+			if b, ok := bgms[key]; !ok {
+				bgms[key] = bgm
+			} else {
+				b.Income += bgm.Income
+				b.TotalIncome += bgm.TotalIncome
+				b.TaxMoney += bgm.TaxMoney
+			}
+			bgms[key].Avs++
+		}
+		archs = make([]*model.ArchiveIncome, 0, len(bgms))
+		for _, b := range bgms {
+			archs = append(archs, b)
+		}
+	}
+	return
+}
+
+func formatDateByGroup(date time.Time, groupType int) string {
+	str := ""
+	if groupType == _groupWeek {
+		date = getStartWeekDate(date)
+		str = date.Format(_layout) + "~" + date.AddDate(0, 0, 6).Format(_layout)
+	} else if groupType == _groupMonth {
+		date = getStartMonthDate(date)
+		str = date.Format(_layoutMonth)
+	} else {
+		str = date.Format(_layout)
+	}
+	return str
+}
+
+func formatArchiveQuery(categoryID []int64, from, to time.Time) string {
+	query := "cdate >= '" + from.Format(_layout) + "'"
+	query += " AND "
+	query += "cdate <= '" + to.Format(_layout) + "'"
+	if len(categoryID) != 0 {
+		query += " AND "
+		query += "category_id in (" + xstr.JoinInts(categoryID) + ")"
+	}
+	return query
+}

app/admin/main/growup/service/income/archive_income_test.go

@@ -0,0 +1,49 @@
+package income
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_ArchiveStatis(t *testing.T) {
+	Convey("ArchiveStatis", t, WithService(func(s *Service) {
+		categoryID := []int64{}
+		groupType := 1
+		var fromTime, endTime int64 = 1524240000000, 1526832000000
+		_, err := s.ArchiveStatis(context.Background(), categoryID, 0, groupType, fromTime, endTime)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func Test_ArchiveSection(t *testing.T) {
+	Convey("ArchiveSection", t, WithService(func(s *Service) {
+		categoryID := []int64{}
+		groupType := 1
+		var fromTime, endTime int64 = 1524240000000, 1526832000000
+		_, err := s.ArchiveSection(context.Background(), categoryID, 0, groupType, fromTime, endTime)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func Test_ArchiveDetail(t *testing.T) {
+	Convey("ArchiveDetail", t, WithService(func(s *Service) {
+		mid := int64(1)
+		groupType := 1
+		var fromTime, endTime int64 = 1524240000000, 1526832000000
+		_, err := s.ArchiveDetail(context.Background(), mid, 0, groupType, fromTime, endTime)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func Test_ArchiveTop(t *testing.T) {
+	Convey("ArchiveTop", t, WithService(func(s *Service) {
+		avIDs := []int64{}
+		groupType := 1
+		var fromTime, endTime int64 = 1524240000000, 1526832000000
+		from, limit := 0, 10
+		_, _, err := s.ArchiveTop(context.Background(), avIDs, 0, groupType, fromTime, endTime, from, limit)
+		So(err, ShouldBeNil)
+	}))
+}

app/admin/main/growup/service/income/av_breach.go

@@ -0,0 +1,359 @@
+package income
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strconv"
+	"time"
+
+	upModel "go-common/app/admin/main/growup/model"
+	model "go-common/app/admin/main/growup/model/income"
+	"go-common/app/admin/main/growup/service"
+
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	xtime "go-common/library/time"
+	"go-common/library/xstr"
+
+	"golang.org/x/sync/errgroup"
+)
+
+// BreachList list
+func (s *Service) BreachList(c context.Context, mids, aids []int64, typ int, fromTime, toTime int64, reason string, from, limit int) (breachs []*model.AvBreach, total int, err error) {
+	query := formatBreachQuery(mids, aids, typ, fromTime, toTime, reason)
+	total, err = s.dao.BreachCount(c, query)
+	if err != nil {
+		log.Error("s.dao.GetBreachCount error(%v)", err)
+		return
+	}
+	query = fmt.Sprintf("%s LIMIT %d,%d", query, from, limit)
+	breachs, err = s.dao.ListArchiveBreach(c, query)
+	if err != nil {
+		log.Error("s.dao.ListArchiveBreach error(%v)", err)
+	}
+
+	mids = make([]int64, 0, len(breachs))
+	for _, b := range breachs {
+		mids = append(mids, b.MID)
+	}
+	nickname, err := s.dao.ListUpInfo(c, mids)
+	for _, b := range breachs {
+		b.Nickname = nickname[b.MID]
+	}
+	return
+}
+
+// BreachStatis statis
+func (s *Service) BreachStatis(c context.Context, mids, aids []int64, typ, groupType int, fromTime, toTime int64, reason string) (date interface{}, err error) {
+	from := getDateByGroup(groupType, time.Unix(fromTime, 0))
+	to := getDateByGroup(groupType, time.Unix(toTime, 0))
+	query := formatBreachQuery(mids, aids, typ, from.Unix(), to.Unix(), reason)
+	breachs, err := s.dao.ListArchiveBreach(c, query)
+	if err != nil {
+		log.Error("s.dao.ListArchiveBreach error(%v)", err)
+		return
+	}
+	date = breachStatis(breachs, from, to, groupType)
+	return
+}
+
+func breachStatis(breachs []*model.AvBreach, from, to time.Time, groupType int) interface{} {
+	dateIncome := make(map[string]int64)
+	dateUps := make(map[string]map[int64]struct{})
+	for _, breach := range breachs {
+		date := formatDateByGroup(breach.CDate.Time(), groupType)
+		if _, ok := dateIncome[date]; ok {
+			dateIncome[date] += breach.Money
+		} else {
+			dateIncome[date] = breach.Money
+		}
+		if _, ok := dateUps[date]; !ok {
+			dateUps[date] = make(map[int64]struct{})
+		}
+		dateUps[date][breach.MID] = struct{}{}
+	}
+
+	income, counts, xAxis := []string{}, []int{}, []string{}
+	// get result by date
+	to = to.AddDate(0, 0, 1)
+	for from.Before(to) {
+		dateStr := formatDateByGroup(from, groupType)
+		xAxis = append(xAxis, dateStr)
+		if val, ok := dateIncome[dateStr]; ok {
+			income = append(income, fmt.Sprintf("%.2f", float64(val)/float64(100)))
+			counts = append(counts, len(dateUps[dateStr]))
+		} else {
+			income = append(income, "0")
+			counts = append(counts, 0)
+		}
+		from = addDayByGroup(groupType, from)
+	}
+
+	return map[string]interface{}{
+		"counts":  counts,
+		"incomes": income,
+		"xaxis":   xAxis,
+	}
+}
+
+// ExportBreach export
+func (s *Service) ExportBreach(c context.Context, mids, aids []int64, typ int, fromTime, toTime int64, reason string, from, limit int) (res []byte, err error) {
+	breachs, _, err := s.BreachList(c, mids, aids, typ, fromTime, toTime, reason, from, limit)
+	if err != nil {
+		log.Error("s.BreachList error(%v)", err)
+		return
+	}
+	records := formatBreach(breachs)
+	res, err = service.FormatCSV(records)
+	if err != nil {
+		log.Error("FormatCSV error(%v)")
+	}
+	return
+}
+
+func formatBreachQuery(mids, aids []int64, typ int, fromTime, toTime int64, reason string) (query string) {
+	query = fmt.Sprintf("cdate >= '%s' AND cdate <= '%s'", time.Unix(fromTime, 0).Format(_layout), time.Unix(toTime, 0).Format(_layout))
+	if typ != 4 {
+		query = fmt.Sprintf("%s AND ctype = %d", query, typ)
+	}
+	if len(mids) > 0 {
+		query = fmt.Sprintf("%s AND mid IN (%s)", query, xstr.JoinInts(mids))
+	}
+	if len(aids) > 0 {
+		query = fmt.Sprintf("%s AND av_id IN (%s)", query, xstr.JoinInts(aids))
+	}
+	if reason != "" {
+		query = fmt.Sprintf("%s AND reason = '%s'", query, reason)
+	}
+	return
+}
+
+// ArchiveBreach breach archive batch
+func (s *Service) ArchiveBreach(c context.Context, typ int, aids []int64, mid int64, reason string, operator string) (err error) {
+	count, err := s.dao.BreachCount(c, fmt.Sprintf("av_id in (%s) AND cdate = '%s'", xstr.JoinInts(aids), time.Now().Format(_layout)))
+	if err != nil {
+		log.Error("s.dao.AvBreachCount error(%v)", err)
+		return
+	}
+	if count > 0 {
+		err = fmt.Errorf("有稿件已被扣除")
+		return
+	}
+	return s.avBreach(c, typ, aids, mid, reason, operator)
+}
+
+func assembleAvBreach(aids []int64, mid int64, ctype int, reason string, breach map[int64]int64, upload map[int64]string) (vals string) {
+	var buf bytes.Buffer
+	for _, aid := range aids {
+		buf.WriteString("(")
+		buf.WriteString(strconv.FormatInt(aid, 10))
+		buf.WriteByte(',')
+		buf.WriteString(strconv.FormatInt(mid, 10))
+		buf.WriteByte(',')
+		buf.WriteString("'" + time.Now().Format(_layout) + "'")
+		buf.WriteByte(',')
+		buf.WriteString(strconv.FormatInt(breach[aid], 10))
+		buf.WriteByte(',')
+		buf.WriteString(strconv.Itoa(ctype))
+		buf.WriteByte(',')
+		buf.WriteString("\"" + reason + "\"")
+		buf.WriteByte(',')
+		buf.WriteString("'" + upload[aid] + "'")
+		buf.WriteString(")")
+		buf.WriteByte(',')
+	}
+	if buf.Len() > 0 {
+		buf.Truncate(buf.Len() - 1)
+	}
+	vals = buf.String()
+	buf.Reset()
+	return
+}
+
+// AvBreach av breach from av_income
+func (s *Service) avBreach(c context.Context, ctype int, aids []int64, mid int64, reason string, operator string) (err error) {
+	archives, withdrawMonth, err := s.GetArchiveByUpAccount(c, ctype, aids, mid)
+	if err != nil {
+		log.Error("s.GetArchiveByUpAccount error(%v)", err)
+		return
+	}
+	if len(archives) == 0 {
+		return
+	}
+	preMonthBreach, thisMonthBreach, avBreach, avUpload := getBreachMoney(archives, withdrawMonth)
+
+	tx, err := s.dao.BeginTran(c)
+	if err != nil {
+		log.Error("s.dao.BeginTran error(%v)", err)
+		return
+	}
+	var eg errgroup.Group
+	// insert av_breach
+	eg.Go(func() (err error) {
+		if _, err = s.dao.TxInsertAvBreach(tx, assembleAvBreach(aids, mid, ctype, reason, avBreach, avUpload)); err != nil {
+			log.Error("s.TxInsertAvBreach error(%v)", err)
+			tx.Rollback()
+		}
+		return
+	})
+
+	// update av breach pre state = 2
+	eg.Go(func() (err error) {
+		if _, err = s.dao.TxUpdateBreachPre(tx, aids, time.Now().Format(_layout)); err != nil {
+			log.Error("s.TxUpdateBreachPre error(%v)", err)
+			tx.Rollback()
+		}
+		return
+	})
+
+	// save av_black_list
+	eg.Go(func() (err error) {
+		if err = s.TxInsertAvBlacklist(c, tx, ctype, aids, mid, _avBreach, len(aids)); err != nil {
+			log.Error("s.InsertAvBlacklist error(%v)", err)
+		}
+		return
+	})
+	// update up_account
+	eg.Go(func() (err error) {
+		if err = s.TxUpAccountBreach(c, tx, mid, preMonthBreach, thisMonthBreach); err != nil {
+			log.Error("s.UpdateUpAccount error(%v)", err)
+		}
+		return
+	})
+	// update up credit score
+	eg.Go(func() (err error) {
+		if err = s.UpdateUpCredit(c, tx, ctype, mid, aids, operator); err != nil {
+			log.Error("s.UpdateUpCredit error(%v)", err)
+		}
+		return
+	})
+
+	eg.Go(func() (err error) {
+		if _, err = s.upDao.TxUpdateAvSpyState(tx, 1, aids); err != nil {
+			tx.Rollback()
+			log.Error("s.upDao.TxUpdateAvSpyState error(%v)", err)
+		}
+		return
+	})
+
+	if err = eg.Wait(); err != nil {
+		log.Error("run eg.Wait error(%v)", err)
+		return
+	}
+
+	if err = tx.Commit(); err != nil {
+		log.Error("tx.Commit error")
+		return
+	}
+
+	var business string
+	switch ctype {
+	case _video:
+		business = "avid"
+	case _column:
+		business = "cv"
+	case _bgm:
+		business = "au"
+	}
+
+	for _, aid := range aids {
+		err = s.msg.Send(c, "1_14_5",
+			fmt.Sprintf("您的稿件 %s %d 违反创作激励计划规则。", business, aid),
+			fmt.Sprintf("您的稿件 %s %d 因为%s原因被取消参加创作激励计划资格，已获得收入将被扣除。如有疑问，请联系客服。", business, aid, reason),
+			[]int64{mid},
+			time.Now().Unix())
+		if err != nil {
+			log.Error("s.msg.Send error(%v)", err)
+			return
+		}
+	}
+
+	return
+}
+
+// UpdateUpCredit update up_info credit score
+func (s *Service) UpdateUpCredit(c context.Context, tx *sql.Tx, ctype int, mid int64, aids []int64, operator string) (err error) {
+	score, err := s.upDao.CreditScore(c, mid)
+	if err != nil {
+		return
+	}
+	// insert credit_score_record
+	creditRecord := &upModel.CreditRecord{
+		MID:       mid,
+		OperateAt: xtime.Time(time.Now().Unix()),
+		Operator:  operator,
+		Reason:    9,
+		Deducted:  3 * len(aids),
+		Remaining: score - 3*len(aids),
+	}
+	r1, err := s.upDao.TxInsertCreditRecord(tx, creditRecord)
+	if err != nil {
+		tx.Rollback()
+		return
+	}
+
+	r2, err := s.upDao.TxUpdateCreditScore(tx, mid, score-3*len(aids))
+	if err != nil {
+		tx.Rollback()
+		return
+	}
+	if r1 != r2 {
+		tx.Rollback()
+		return
+	}
+	return
+}
+
+// GetArchiveByUpAccount get archive income by withdraw date
+func (s *Service) GetArchiveByUpAccount(c context.Context, typ int, aids []int64, mid int64) (archives []*model.ArchiveIncome, withdrawMonth time.Month, err error) {
+	archives = make([]*model.ArchiveIncome, 0)
+	upAccount, err := s.dao.GetUpAccount(c, mid)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			err = nil
+			return
+		}
+		log.Error("s.dao.GetUpAccount error(%v)", err)
+		return
+	}
+
+	withdrawDateStr := upAccount.WithdrawDateVersion + "-01"
+	withdrawDate, err := time.Parse(_layout, withdrawDateStr)
+	if err != nil {
+		log.Error("time.Parse error(%v)", err)
+		return
+	}
+	withdrawMonth = withdrawDate.AddDate(0, 1, 0).Month()
+	from, now := withdrawDate.AddDate(0, 1, 0).Format(_layout), time.Now().Format(_layout)
+	query := ""
+	switch typ {
+	case _video:
+		query = fmt.Sprintf("av_id in (%s)", xstr.JoinInts(aids))
+	case _column:
+		query = fmt.Sprintf("aid in (%s)", xstr.JoinInts(aids))
+	case _bgm:
+		query = fmt.Sprintf("sid in (%s)", xstr.JoinInts(aids))
+	}
+	archives, err = s.GetArchiveIncome(c, typ, query, from, now)
+	if err != nil {
+		log.Error("s.GetArchiveIncome error(%v)", err)
+	}
+	return
+}
+
+func getBreachMoney(archives []*model.ArchiveIncome, withdrawMonth time.Month) (int64, int64, map[int64]int64, map[int64]string) {
+	var preMonthBreach, thisMonthBreach int64 = 0, 0
+	avBreach := make(map[int64]int64)
+	avUpload := make(map[int64]string)
+	for _, arch := range archives {
+		if arch.Date.Time().Month() == withdrawMonth {
+			preMonthBreach += arch.Income
+		} else {
+			thisMonthBreach += arch.Income
+		}
+		avBreach[arch.AvID] += arch.Income
+		avUpload[arch.AvID] = arch.UploadTime.Time().Format(_layout)
+	}
+	return preMonthBreach, thisMonthBreach, avBreach, avUpload
+}

app/admin/main/growup/service/income/av_breach_test.go

@@ -0,0 +1,19 @@
+package income
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_ArchiveBreach(t *testing.T) {
+	Convey("ArchiveBreach", t, WithService(func(s *Service) {
+		avID := []int64{}
+		mid := int64(1)
+		reason := "test"
+		operator := "szy"
+		err := s.ArchiveBreach(context.Background(), 0, avID, mid, reason, operator)
+		So(err, ShouldBeNil)
+	}))
+}

app/admin/main/growup/service/income/blacklist.go

@@ -0,0 +1,102 @@
+package income
+
+import (
+	"bytes"
+	"context"
+	"strconv"
+
+	model "go-common/app/admin/main/growup/model/income"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+// ArchiveBlack stop archives income, add archive into av_black_list
+func (s *Service) ArchiveBlack(c context.Context, typ int, aIDs []int64, mid int64) (err error) {
+	if len(aIDs) == 0 {
+		return
+	}
+	tx, err := s.dao.BeginTran(c)
+	if err != nil {
+		log.Error("s.dao.BeginTran error(%v)", err)
+		return
+	}
+
+	if err = s.TxInsertAvBlacklist(c, tx, typ, aIDs, mid, _avBlack, len(aIDs)); err != nil {
+		log.Error("s.InsertAvBlacklist error(%v)", err)
+		return
+	}
+
+	if err = tx.Commit(); err != nil {
+		log.Error("tx.Commit error")
+	}
+	return
+}
+
+// GetAvBlackListByAvIds get av_black_list by av_id and ctype
+func (s *Service) GetAvBlackListByAvIds(c context.Context, avs []*model.ArchiveIncome, ctype int) (avBMap map[int64]struct{}, err error) {
+	avIDMap := make(map[int64]struct{})
+	for _, av := range avs {
+		avIDMap[av.AvID] = struct{}{}
+	}
+	avIDList := []int64{}
+	for avID := range avIDMap {
+		avIDList = append(avIDList, avID)
+	}
+	avBMap = make(map[int64]struct{})
+	if len(avIDList) > 0 {
+		avBMap, err = s.dao.ListAvBlackList(c, avIDList, ctype)
+		if err != nil {
+			log.Error("s.dao.ListAvBlackList error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// TxInsertAvBlacklist insert av_black_list
+func (s *Service) TxInsertAvBlacklist(c context.Context, tx *sql.Tx, ctype int, aIDs []int64, mid int64, reason int, count int) (err error) {
+	nickname, err := s.dao.GetUpInfoNicknameByMID(c, mid, getUpInfoTable(ctype))
+	if err != nil {
+		log.Error("s.dao.GetUpInfoNicknameByMID error(%v)", err)
+		return
+	}
+	isDeleted, hasSigned := 0, 0
+	if nickname != "" {
+		hasSigned = 1
+	}
+
+	var buf bytes.Buffer
+	for _, id := range aIDs {
+		buf.WriteString("(")
+		buf.WriteString(strconv.FormatInt(id, 10))
+		buf.WriteByte(',')
+		buf.WriteString(strconv.FormatInt(mid, 10))
+		buf.WriteByte(',')
+		buf.WriteString(strconv.Itoa(ctype))
+		buf.WriteByte(',')
+		buf.WriteString(strconv.Itoa(reason))
+		buf.WriteByte(',')
+		buf.WriteString("\"" + nickname + "\"")
+		buf.WriteByte(',')
+		buf.WriteString(strconv.Itoa(hasSigned))
+		buf.WriteByte(',')
+		buf.WriteString(strconv.Itoa(isDeleted))
+		buf.WriteString(")")
+		buf.WriteByte(',')
+	}
+	if buf.Len() > 0 {
+		buf.Truncate(buf.Len() - 1)
+	}
+	vals := buf.String()
+	buf.Reset()
+
+	rows, err := s.dao.TxInsertAvBlackList(tx, vals)
+	if err != nil {
+		tx.Rollback()
+		return
+	}
+	if rows < int64(count) {
+		log.Info("TxInsertAvBlackList(%v) rows(%d) < count(%d) error", vals, rows, count)
+	}
+	return
+}

app/admin/main/growup/service/income/blacklist_test.go

@@ -0,0 +1,15 @@
+package income
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_GetAvBlackListByAvIds(t *testing.T) {
+	Convey("GetAvBlackListByAvIds", t, WithService(func(s *Service) {
+		_, err := s.GetAvBlackListByAvIds(context.Background(), nil, 0)
+		So(err, ShouldBeNil)
+	}))
+}

app/admin/main/growup/service/income/charge.go

@@ -0,0 +1,227 @@
+package income
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/growup/dao/resource"
+	model "go-common/app/admin/main/growup/model/income"
+
+	"go-common/library/log"
+)
+
+// ArchiveChargeStatis av_charge statis
+func (s *Service) ArchiveChargeStatis(c context.Context, categoryID []int64, typ, groupType int, fromTime, toTime int64) (data interface{}, err error) {
+	table := setChargeTableByGroup(typ, groupType)
+	from := getDateByGroup(groupType, time.Unix(fromTime, 0))
+	to := getDateByGroup(groupType, time.Unix(toTime, 0))
+	query := formatArchiveQuery(categoryID, from, to)
+
+	archives, err := s.GetArchiveChargeStatis(c, table, query)
+	if err != nil {
+		log.Error("s.GetArchiveChargeStatis error(%v)", err)
+		return
+	}
+
+	data = archiveChargeStatis(archives, from, to, groupType)
+	return
+}
+
+func archiveChargeStatis(archs []*model.ArchiveChargeStatis, from, to time.Time, groupType int) interface{} {
+	avsMap := make(map[string]*model.ArchiveChargeStatis)
+	ctgyMap := make(map[string]bool)
+	for _, arch := range archs {
+		date := formatDateByGroup(arch.CDate.Time(), groupType)
+		ctgykey := date + strconv.FormatInt(arch.CategroyID, 10)
+		if val, ok := avsMap[date]; ok {
+			val.Avs += arch.Avs
+			if !ctgyMap[ctgykey] {
+				val.Charge += arch.Charge
+				ctgyMap[ctgykey] = true
+			}
+		} else {
+			avsMap[date] = &model.ArchiveChargeStatis{
+				Avs:    arch.Avs,
+				Charge: arch.Charge,
+			}
+			ctgyMap[ctgykey] = true
+		}
+	}
+
+	charge, counts, xAxis := []string{}, []int64{}, []string{}
+	// get result by date
+	to = to.AddDate(0, 0, 1)
+	for from.Before(to) {
+		dateStr := formatDateByGroup(from, groupType)
+		xAxis = append(xAxis, dateStr)
+		if val, ok := avsMap[dateStr]; ok {
+			charge = append(charge, fmt.Sprintf("%.2f", float64(val.Charge)/float64(100)))
+			counts = append(counts, val.Avs)
+		} else {
+			charge = append(charge, "0")
+			counts = append(counts, int64(0))
+		}
+		from = addDayByGroup(groupType, from)
+	}
+
+	return map[string]interface{}{
+		"counts":  counts,
+		"charges": charge,
+		"xaxis":   xAxis,
+	}
+}
+
+// ArchiveChargeSection get av_charge section
+func (s *Service) ArchiveChargeSection(c context.Context, categoryID []int64, typ, groupType int, fromTime, toTime int64) (data interface{}, err error) {
+	table := setChargeTableByGroup(typ, groupType)
+	from := getDateByGroup(groupType, time.Unix(fromTime, 0))
+	to := getDateByGroup(groupType, time.Unix(toTime, 0))
+	query := formatArchiveQuery(categoryID, from, to)
+
+	archives, err := s.GetArchiveChargeStatis(c, table, query)
+	if err != nil {
+		log.Error("s.GetArchiveChargeStatis error(%v)", err)
+		return
+	}
+
+	data = archiveChargeSection(archives, from, to, groupType)
+	return
+}
+
+func archiveChargeSection(archs []*model.ArchiveChargeStatis, from, to time.Time, groupType int) interface{} {
+	ret := make([]map[string]interface{}, 0)
+	avsMap := make(map[string][]int64)
+	for _, arch := range archs {
+		date := formatDateByGroup(arch.CDate.Time(), groupType)
+		if val, ok := avsMap[date]; ok {
+			val[arch.MoneySection] += arch.Avs
+		} else {
+			avsMap[date] = make([]int64, 12)
+			avsMap[date][arch.MoneySection] = arch.Avs
+			ret = append(ret, map[string]interface{}{
+				"date_format": date,
+				"sections":    avsMap[date],
+			})
+		}
+	}
+	return ret
+}
+
+// ArchiveChargeDetail archive charge details
+func (s *Service) ArchiveChargeDetail(c context.Context, aid int64, typ int) (archives []*model.ArchiveCharge, err error) {
+	switch typ {
+	case _video:
+		archives, err = s.GetAvCharges(c, aid)
+	case _column:
+		archives, err = s.dao.GetColumnCharges(c, aid)
+	case _bgm:
+		archives, err = s.dao.GetBgmCharges(c, aid)
+	default:
+		err = fmt.Errorf("type error")
+	}
+	if err != nil {
+		log.Error("s.GetArchives(%d) error(%v)", typ, err)
+		return
+	}
+	err = s.archiveChargeDetail(c, archives, aid, typ)
+	return
+}
+
+func (s *Service) archiveChargeDetail(c context.Context, archs []*model.ArchiveCharge, aid int64, typ int) (err error) {
+	if len(archs) == 0 {
+		return
+	}
+	// get up nickname
+	nickname, err := resource.NameByMID(c, archs[0].MID)
+	if err != nil {
+		return
+	}
+
+	var table, query string
+	switch typ {
+	case _video:
+		table, query = "av_charge_statis", fmt.Sprintf("av_id = %d", aid)
+	case _column:
+		table, query = "column_charge_statis", fmt.Sprintf("aid = %d", aid)
+	case _bgm:
+		table, query = "bgm_charge_statis", fmt.Sprintf("sid = %d", aid)
+	}
+	totalCharge, err := s.dao.GetTotalCharge(c, table, query)
+	if err != nil {
+		log.Error("s.GetTotalCharge error(%v)", err)
+		return
+	}
+	sort.Slice(archs, func(i, j int) bool {
+		return archs[i].Date > archs[j].Date
+	})
+	for _, arch := range archs {
+		arch.TotalCharge = totalCharge
+		arch.Nickname = nickname
+		totalCharge -= arch.Charge
+	}
+	return
+}
+
+// BgmChargeDetail bgm charge detail
+func (s *Service) BgmChargeDetail(c context.Context, sid int64) (archives []*model.ArchiveCharge, err error) {
+	archives = make([]*model.ArchiveCharge, 0)
+	bgms, err := s.dao.GetBgmCharges(c, sid)
+	if err != nil {
+		log.Error("s.dao.GetBgmCharges error(%v)", err)
+		return
+	}
+	avIDs := make(map[int64]struct{})
+	for _, bgm := range bgms {
+		avIDs[bgm.AvID] = struct{}{}
+	}
+	for avID := range avIDs {
+		var avs []*model.ArchiveCharge
+		avs, err = s.ArchiveChargeDetail(c, avID, _video)
+		if err != nil {
+			log.Error("s.ArchiveChargeDetail error(%v)", err)
+			return
+		}
+		archives = append(archives, avs...)
+	}
+	return
+}
+
+// UpRatio up charge ratio
+func (s *Service) UpRatio(c context.Context, from, limit int64) (map[int64]int64, error) {
+	return s.dao.UpRatio(c, from, limit)
+}
+
+// GetAvCharges get av charge by av id
+func (s *Service) GetAvCharges(c context.Context, avID int64) (avs []*model.ArchiveCharge, err error) {
+	avs = make([]*model.ArchiveCharge, 0)
+	for i := 1; i <= 12; i++ {
+		var av []*model.ArchiveCharge
+		av, err = s.dao.GetAvDailyCharge(c, i, avID)
+		if err != nil {
+			return
+		}
+		avs = append(avs, av...)
+	}
+	return
+}
+
+// GetArchiveChargeStatis get archive charge date statis
+func (s *Service) GetArchiveChargeStatis(c context.Context, table, query string) (archs []*model.ArchiveChargeStatis, err error) {
+	offset, size := 0, 2000
+	for {
+		var arch []*model.ArchiveChargeStatis
+		arch, err = s.dao.GetArchiveChargeStatis(c, table, query, offset, size)
+		if err != nil {
+			return
+		}
+		archs = append(archs, arch...)
+		if len(arch) < size {
+			break
+		}
+		offset += len(arch)
+	}
+	return
+}

app/admin/main/growup/service/income/const.go

@@ -0,0 +1,201 @@
+package income
+
+import (
+	"time"
+)
+
+var (
+	_layout      = "2006-01-02"
+	_layoutMonth = "2006-01"
+)
+
+const (
+	_upIncome        = "up_income"
+	_upIncomeWeekly  = "up_income_weekly"
+	_upIncomeMonthly = "up_income_monthly"
+
+	_avDailyStatis   = "av_income_daily_statis"
+	_avWeeklyStatis  = "av_income_weekly_statis"
+	_avMonthlyStatis = "av_income_monthly_statis"
+
+	_cmDailyStatis   = "column_income_daily_statis"
+	_cmWeeklyStatis  = "column_income_weekly_statis"
+	_cmMonthlyStatis = "column_income_monthly_statis"
+
+	_bgmDailyStatis   = "bgm_income_daily_statis"
+	_bgmWeeklyStatis  = "bgm_income_weekly_statis"
+	_bgmMonthlyStatis = "bgm_income_monthly_statis"
+
+	_avChargeDailyStatis   = "av_charge_daily_statis"
+	_avChargeWeeklyStatis  = "av_charge_weekly_statis"
+	_avChargeMonthlyStatis = "av_charge_monthly_statis"
+
+	_cmChargeDailyStatis   = "column_charge_daily_statis"
+	_cmChargeWeeklyStatis  = "column_charge_weekly_statis"
+	_cmChargeMonthlyStatis = "column_charge_monthly_statis"
+
+	_bgmChargeDailyStatis   = "bgm_charge_daily_statis"
+	_bgmChargeWeeklyStatis  = "bgm_charge_weekly_statis"
+	_bgmChargeMonthlyStatis = "bgm_charge_monthly_statis"
+
+	_upIncomeDailyStatis = "up_income_daily_statis"
+	_upAvDailyStatis     = "up_av_daily_statis"
+	_upColumnDailyStatis = "up_column_daily_statis"
+	_upBgmDailyStatis    = "up_bgm_daily_statis"
+
+	_groupDay   = 1
+	_groupWeek  = 2
+	_groupMonth = 3
+
+	_video = 0
+	// _audio  = 1
+	_column  = 2
+	_bgm     = 3
+	_up      = 4
+	_lottery = 5 // 动态抽奖
+
+	_leastAvIncome = 30000
+
+	// add blacklist reason
+	_avBlack  = 1
+	_avBreach = 2
+)
+
+func getUpInfoTable(typ int) (table string) {
+	switch typ {
+	case _video:
+		table = "up_info_video"
+	case _column:
+		table = "up_info_column"
+	case _bgm:
+		table = "up_info_bgm"
+	}
+	return
+}
+
+func getUpInfoByType(typ int) (table string, incomeType string) {
+	switch typ {
+	case _video:
+		table, incomeType = _upAvDailyStatis, "av_income"
+	case _column:
+		table, incomeType = _upColumnDailyStatis, "column_income"
+	case _bgm:
+		table, incomeType = _upBgmDailyStatis, "bgm_income"
+	case _up:
+		table, incomeType = _upIncomeDailyStatis, "income"
+	}
+	return
+}
+
+func getUpFieldByType(typ int) (field string) {
+	switch typ {
+	case _video:
+		field = "av_income,av_tax,av_base_income,av_total_income"
+	case _column:
+		field = "column_income,column_tax,column_base_income,column_total_income"
+	case _bgm:
+		field = "bgm_income,bgm_tax,bgm_base_income,bgm_total_income"
+	case _up:
+		field = "income,tax_money,base_income,total_income"
+	}
+	return
+}
+
+func setUpTableByGroup(groupType int) string {
+	table := _upIncome
+	if groupType == _groupWeek {
+		table = _upIncomeWeekly
+	} else if groupType == _groupMonth {
+		table = _upIncomeMonthly
+	}
+	return table
+}
+
+func setArchiveTableByGroup(typ, groupType int) string {
+	table := ""
+	switch typ {
+	case _video:
+		table = _avDailyStatis
+		if groupType == _groupWeek {
+			table = _avWeeklyStatis
+		} else if groupType == _groupMonth {
+			table = _avMonthlyStatis
+		}
+	case _column:
+		table = _cmDailyStatis
+		if groupType == _groupWeek {
+			table = _cmWeeklyStatis
+		} else if groupType == _groupMonth {
+			table = _cmMonthlyStatis
+		}
+	case _bgm:
+		table = _bgmDailyStatis
+		if groupType == _groupWeek {
+			table = _bgmWeeklyStatis
+		} else if groupType == _groupMonth {
+			table = _bgmMonthlyStatis
+		}
+	}
+	return table
+}
+
+func setChargeTableByGroup(typ, groupType int) string {
+	table := ""
+	switch typ {
+	case _video:
+		table = _avChargeDailyStatis
+		if groupType == _groupWeek {
+			table = _avChargeWeeklyStatis
+		} else if groupType == _groupMonth {
+			table = _avChargeMonthlyStatis
+		}
+	case _column:
+		table = _cmChargeDailyStatis
+		if groupType == _groupWeek {
+			table = _cmChargeWeeklyStatis
+		} else if groupType == _groupMonth {
+			table = _cmChargeMonthlyStatis
+		}
+	case _bgm:
+		table = _bgmChargeDailyStatis
+		if groupType == _groupWeek {
+			table = _bgmChargeWeeklyStatis
+		} else if groupType == _groupMonth {
+			table = _bgmChargeMonthlyStatis
+		}
+	}
+	return table
+}
+
+func getDateByGroup(groupType int, date time.Time) time.Time {
+	if groupType == _groupWeek {
+		return getStartWeekDate(date)
+	} else if groupType == _groupMonth {
+		return getStartMonthDate(date)
+	}
+	return date
+}
+
+func addDayByGroup(groupType int, date time.Time) time.Time {
+	if groupType == _groupWeek {
+		return date.AddDate(0, 0, 7)
+	} else if groupType == _groupMonth {
+		return date.AddDate(0, 1, 0)
+	}
+	return date.AddDate(0, 0, 1)
+}
+
+func getStartWeekDate(date time.Time) time.Time {
+	for date.Weekday() != time.Monday {
+		date = date.AddDate(0, 0, -1)
+	}
+	return date
+}
+
+func getStartMonthDate(date time.Time) time.Time {
+	return time.Date(date.Year(), date.Month(), 1, 0, 0, 0, 0, time.Local)
+}
+
+func fromYuanToFen(d int64) float64 {
+	return float64(d) / float64(100)
+}

app/admin/main/growup/service/income/format.go

@@ -0,0 +1,105 @@
+package income
+
+import (
+	"fmt"
+	"strconv"
+
+	model "go-common/app/admin/main/growup/model/income"
+)
+
+func formatUpWithdraw(ups []*model.UpWithdrawRes, isDeleted int) (data [][]string) {
+	if len(ups) <= 0 {
+		return
+	}
+	data = make([][]string, len(ups)+1)
+	if isDeleted == 0 {
+		data[0] = []string{"UID", "昵称", "已提现", "未提现", "最近提现时间"}
+		for i := 1; i <= len(ups); i++ {
+			up := ups[i-1]
+			data[i] = []string{
+				strconv.FormatInt(up.MID, 10),
+				up.Nickname,
+				up.WithdrawIncome,
+				up.UnWithdrawIncome,
+				up.WithdrawDate,
+			}
+		}
+	} else {
+		data[0] = []string{"UID", "昵称", "禁止提现", "禁止时间", "已提现", "最近提现时间"}
+		for i := 1; i <= len(ups); i++ {
+			up := ups[i-1]
+			data[i] = []string{
+				strconv.FormatInt(up.MID, 10),
+				up.Nickname,
+				up.UnWithdrawIncome,
+				up.MTime.Time().Format(_layout),
+				up.WithdrawIncome,
+				up.WithdrawDate,
+			}
+		}
+	}
+	return
+}
+
+func formatUpIncomeWithdraw(ups []*model.UpIncomeWithdraw) (data [][]string) {
+	if len(ups) <= 0 {
+		return
+	}
+	data = make([][]string, len(ups)+1)
+	data[0] = []string{"最近一次提现日期", "UP主ID", "UP主昵称", "已经提现的收入"}
+	for i := 1; i <= len(ups); i++ {
+		up := ups[i-1]
+		data[i] = []string{
+			up.MTime.Time().Format("2006-01-02"),
+			strconv.FormatInt(up.MID, 10),
+			up.Nickname,
+			fmt.Sprintf("%.2f", fromYuanToFen(up.WithdrawIncome)),
+		}
+	}
+	return
+}
+
+func formatUpIncome(ups []*model.UpIncome) (data [][]string) {
+	if len(ups) <= 0 {
+		return
+	}
+	data = make([][]string, 1)
+	data[0] = []string{"时间", "UID", "昵称", "新增收入", "稿件数", "基础收入", "额外收入", "违规扣除", "扣税金额", "累计收入"}
+	for _, up := range ups {
+		data = append(data, []string{
+			up.DateFormat,
+			strconv.FormatInt(up.MID, 10),
+			up.Nickname,
+			fmt.Sprintf("%.2f", fromYuanToFen(up.Income)),
+			strconv.FormatInt(up.AvCount, 10),
+			fmt.Sprintf("%.2f", fromYuanToFen(up.BaseIncome)),
+			fmt.Sprintf("%.2f", fromYuanToFen(up.ExtraIncome)),
+			fmt.Sprintf("%.2f", fromYuanToFen(up.Breach)),
+			fmt.Sprintf("%.2f", fromYuanToFen(up.TaxMoney)),
+			fmt.Sprintf("%.2f", fromYuanToFen(up.TotalIncome)),
+		})
+	}
+	return
+}
+
+func formatBreach(breachs []*model.AvBreach) (data [][]string) {
+	if len(breachs) <= 0 {
+		return
+	}
+	ctype := []string{"视频", "音频", "专栏", "素材"}
+	data = make([][]string, 1)
+	data[0] = []string{"日期", "稿件id", "稿件类型", "投稿时间", "UID", "up主昵称", "扣除金额", "扣除原因"}
+	for _, b := range breachs {
+		data = append(data, []string{
+			b.CDate.Time().Format(_layout),
+			strconv.FormatInt(b.AvID, 10),
+			ctype[b.CType],
+			b.UploadTime.Time().Format(_layout),
+			strconv.FormatInt(b.MID, 10),
+			b.Nickname,
+			fmt.Sprintf("%.2f", fromYuanToFen(b.Money)),
+			b.Reason,
+		})
+	}
+	return
+}

app/admin/main/growup/service/income/lottery.go

@@ -0,0 +1,39 @@
+package income
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	model "go-common/app/admin/main/growup/model/income"
+
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+func (s *Service) lotteryStatis(c context.Context, categoryID []int64, from, to time.Time, groupType int) (data interface{}, err error) {
+	query := ""
+	if len(categoryID) != 0 {
+		query = fmt.Sprintf("tag_id in (%s)", xstr.JoinInts(categoryID))
+	}
+	avs, err := s.GetArchiveIncome(c, _lottery, query, from.Format(_layout), to.Format(_layout))
+	if err != nil {
+		log.Error("s.GetArchiveIncome error(%v)")
+		return
+	}
+	avsMap := make(map[string]*model.ArchiveStatis)
+	for _, av := range avs {
+		date := formatDateByGroup(av.Date.Time(), groupType)
+		if val, ok := avsMap[date]; ok {
+			val.Income += av.Income
+			val.Avs++
+		} else {
+			avsMap[date] = &model.ArchiveStatis{
+				Income: av.Income,
+				Avs:    1,
+			}
+		}
+	}
+	data = parseArchiveStatis(avsMap, from, to, groupType)
+	return
+}

app/admin/main/growup/service/income/service.go

@@ -0,0 +1,39 @@
+package income
+
+import (
+	"context"
+
+	"go-common/app/admin/main/growup/conf"
+	upD "go-common/app/admin/main/growup/dao"
+	incomeD "go-common/app/admin/main/growup/dao/income"
+	"go-common/app/admin/main/growup/dao/message"
+)
+
+// Service struct
+type Service struct {
+	conf  *conf.Config
+	dao   *incomeD.Dao
+	msg   *message.Dao
+	upDao *upD.Dao
+}
+
+// New fn
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		conf:  c,
+		dao:   incomeD.New(c),
+		msg:   message.New(c),
+		upDao: upD.New(c),
+	}
+	return s
+}
+
+// Ping check dao health.
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+// Close dao
+func (s *Service) Close() {
+	s.dao.Close()
+}

app/admin/main/growup/service/income/service_test.go

@@ -0,0 +1,28 @@
+package income
+
+import (
+	"flag"
+	"path/filepath"
+	"time"
+
+	"go-common/app/admin/main/growup/conf"
+)
+
+var (
+	s *Service
+)
+
+func init() {
+	dir, _ := filepath.Abs("../../cmd/growup-admin.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	s = New(conf.Conf)
+	time.Sleep(time.Second)
+}
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		// Reset(func() { CleanCache() })
+		f(s)
+	}
+}

app/admin/main/growup/service/income/up_account.go

@@ -0,0 +1,95 @@
+package income
+
+import (
+	"context"
+	"fmt"
+
+	model "go-common/app/admin/main/growup/model/income"
+
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+// GetUpAccount get up_account
+func (s *Service) GetUpAccount(c context.Context, query string, isDeleted int) (ups []*model.UpAccount, err error) {
+	from, limit := 0, 2000
+	for {
+		var up []*model.UpAccount
+		up, err = s.ListUpAccount(c, query, isDeleted, from, limit)
+		if err != nil {
+			return
+		}
+		ups = append(ups, up...)
+		if len(up) < limit {
+			break
+		}
+		from += limit
+	}
+	return
+}
+
+// TxUpAccountBreach up_account breach
+func (s *Service) TxUpAccountBreach(c context.Context, tx *sql.Tx, mid, preMonthBreach, thisMonthBreach int64) error {
+	if mid <= 0 {
+		return fmt.Errorf("请输入正确的mid,请确认")
+	}
+	if preMonthBreach < 0 {
+		return fmt.Errorf("未提现金额必须大于等于零,请确认")
+	}
+	if thisMonthBreach < 0 {
+		return fmt.Errorf("当前月未提现金额必须大于等于零,请确认")
+	}
+
+	times := 0
+	for {
+		upAccount, err := s.dao.GetUpAccount(c, mid)
+		if err != nil {
+			log.Error("s.dao.GetUpAccount error(%v)", err)
+			return err
+		}
+
+		total := upAccount.TotalIncome - preMonthBreach - thisMonthBreach
+		unwithdraw := upAccount.TotalUnwithdrawIncome - preMonthBreach
+		if total < 0 {
+			log.Info("up_account(%d) total(%d) < 0", mid, total)
+			total = 0
+		}
+		if unwithdraw < 0 {
+			log.Info("up_account(%d) total_unwithdraw_income(%d) < 0", mid, unwithdraw)
+			unwithdraw = 0
+		}
+
+		rows, err := s.dao.TxBreachUpAccount(tx, total, unwithdraw, mid, upAccount.Version+1, upAccount.Version)
+		if err != nil {
+			tx.Rollback()
+			log.Error("s.dao.TxBreachUpAccount error(%v)", err)
+			return err
+		}
+		if rows == 1 {
+			break
+		}
+
+		times++
+		if times >= 5 {
+			tx.Rollback()
+			return fmt.Errorf("更新up主金额错误")
+		}
+	}
+	return nil
+}
+
+// UpAccountCount get up_account count
+func (s *Service) UpAccountCount(c context.Context, query string, isDeleted int) (total int64, err error) {
+	if query != "" {
+		query += " AND"
+	}
+	return s.dao.UpAccountCount(c, query, isDeleted)
+}
+
+// ListUpAccount list up account bu query
+func (s *Service) ListUpAccount(c context.Context, query string, isDeleted, from, limit int) (ups []*model.UpAccount, err error) {
+	if query != "" {
+		query += " AND"
+	}
+	return s.dao.ListUpAccount(c, query, isDeleted, from, limit)
+}

app/admin/main/growup/service/income/up_account_test.go

@@ -0,0 +1,22 @@
+package income
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_TxUpAccountBreach(t *testing.T) {
+	Convey("TxUpAccountBreach", t, WithService(func(s *Service) {
+		tx, _ := s.dao.BeginTran(context.Background())
+		err := s.TxUpAccountBreach(context.Background(), tx, 11, -1, 1)
+		So(err, ShouldNotBeNil)
+	}))
+
+	Convey("TxUpAccountBreach", t, WithService(func(s *Service) {
+		tx, _ := s.dao.BeginTran(context.Background())
+		err := s.TxUpAccountBreach(context.Background(), tx, 11, 1, -1)
+		So(err, ShouldNotBeNil)
+	}))
+}

app/admin/main/growup/service/income/up_category_info.go

@@ -0,0 +1,29 @@
+package income
+
+import (
+	"context"
+
+	model "go-common/app/admin/main/growup/model/income"
+	"go-common/library/log"
+)
+
+// GetUpInfoByAIDs get up_info by av id
+func (s *Service) GetUpInfoByAIDs(c context.Context, avs []*model.ArchiveIncome) (upInfoMap map[int64]string, err error) {
+	midMap := make(map[int64]struct{})
+	for _, av := range avs {
+		midMap[av.MID] = struct{}{}
+	}
+	midList := []int64{}
+	for mid := range midMap {
+		midList = append(midList, mid)
+	}
+	upInfoMap = make(map[int64]string)
+	if len(midList) > 0 {
+		upInfoMap, err = s.dao.ListUpInfo(c, midList)
+		if err != nil {
+			log.Error("s.dao.ListUpInfo error(%v)", err)
+			return
+		}
+	}
+	return
+}

app/admin/main/growup/service/income/up_category_info_test.go

@@ -0,0 +1,15 @@
+package income
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_GetUpInfoByAIDs(t *testing.T) {
+	Convey("GetUpInfoByAIDs", t, WithService(func(s *Service) {
+		_, err := s.GetUpInfoByAIDs(context.Background(), nil)
+		So(err, ShouldBeNil)
+	}))
+}

app/admin/main/growup/service/income/up_income.go

@@ -0,0 +1,232 @@
+package income
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"time"
+
+	model "go-common/app/admin/main/growup/model/income"
+	"go-common/app/admin/main/growup/service"
+
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+// UpIncomeList up income list
+func (s *Service) UpIncomeList(c context.Context, mids []int64, typ, groupType int, fromTime, toTime, minIncome, maxIncome int64, from, limit int) (upIncome []*model.UpIncome, total int, err error) {
+	table := setUpTableByGroup(groupType)
+	_, incomeType := getUpInfoByType(typ)
+	fromDate := getDateByGroup(groupType, time.Unix(fromTime, 0))
+	toDate := getDateByGroup(groupType, time.Unix(toTime, 0))
+	typeField := getUpFieldByType(typ)
+	query := formatUpQuery(mids, fromDate, toDate, incomeType)
+	if maxIncome != 0 || minIncome != 0 {
+		query = fmt.Sprintf("%s AND %s >= %d AND %s <= %d", query, incomeType, minIncome, incomeType, maxIncome)
+	}
+	total, err = s.dao.UpIncomeCount(c, table, query)
+	if err != nil {
+		log.Error("s.dao.UpIncomeCount error(%v)", err)
+		return
+	}
+
+	upIncome, err = s.dao.GetUpIncomeBySort(c, table, typeField, incomeType, query, from, limit)
+	if err != nil {
+		log.Error("s.dao.GetUpIncomeBySort error(%v)", err)
+		return
+	}
+	if len(upIncome) == 0 {
+		return
+	}
+	for _, up := range upIncome {
+		mids = append(mids, up.MID)
+	}
+
+	nicknames, err := s.dao.ListUpInfo(c, mids)
+	if err != nil {
+		log.Error("s.dao.ListUpInfo error(%v)", err)
+		return
+	}
+
+	var breachType []int64
+	switch typ {
+	case _video:
+		breachType = []int64{0}
+	case _column:
+		breachType = []int64{2}
+	case _bgm:
+		breachType = []int64{3}
+	case _up:
+		breachType = []int64{0, 1, 2, 3}
+	}
+	breachs, err := s.dao.GetAvBreachByMIDs(c, mids, breachType)
+	if err != nil {
+		log.Error("s.dao.GetAvBreachByMIDs error(%v)", err)
+		return
+	}
+	upIncomeList(upIncome, nicknames, breachs, typ, groupType)
+	return
+}
+
+func upIncomeList(upIncome []*model.UpIncome, nicknames map[int64]string, breachs []*model.AvBreach, typ, groupType int) {
+	midDateBreach := make(map[int64]map[string]int64) // map[mid][date] = money
+	for _, b := range breachs {
+		dateFormat := formatDateByGroup(b.CDate.Time(), groupType)
+		if _, ok := midDateBreach[b.MID]; !ok {
+			midDateBreach[b.MID] = make(map[string]int64)
+		}
+		midDateBreach[b.MID][dateFormat] += b.Money
+	}
+
+	for _, up := range upIncome {
+		up.Nickname = nicknames[up.MID]
+		up.DateFormat = formatDateByGroup(up.Date.Time(), groupType)
+		up.ExtraIncome = up.Income - up.BaseIncome
+		if _, ok := midDateBreach[up.MID]; ok {
+			up.Breach = midDateBreach[up.MID][up.DateFormat]
+		}
+		switch typ {
+		case _video:
+			up.Count = up.AvCount
+		case _column:
+			up.Count = up.ColumnCount
+		case _bgm:
+			up.Count = up.BgmCount
+		case _up:
+			up.Count = up.AvCount + up.ColumnCount + up.BgmCount
+		}
+	}
+}
+
+// UpIncomeListExport up income list
+func (s *Service) UpIncomeListExport(c context.Context, mids []int64, typ, groupType int, fromTime, toTime, minIncome, maxIncome int64, from, limit int) (res []byte, err error) {
+	ups, _, err := s.UpIncomeList(c, mids, typ, groupType, fromTime, toTime, minIncome, maxIncome, from, limit)
+	if err != nil {
+		log.Error("s.UpIncomeList error(%v)", err)
+		return
+	}
+	records := formatUpIncome(ups)
+	res, err = service.FormatCSV(records)
+	if err != nil {
+		log.Error("FormatCSV error(%v)")
+	}
+	return
+}
+
+// UpIncomeStatis up income statis
+func (s *Service) UpIncomeStatis(c context.Context, mids []int64, typ, groupType int, fromTime, toTime int64) (data interface{}, err error) {
+	from := getDateByGroup(groupType, time.Unix(fromTime, 0))
+	to := getDateByGroup(groupType, time.Unix(toTime, 0))
+	if groupType == _groupDay && len(mids) == 0 {
+		return s.upStatisDaily(c, typ, from, to)
+	}
+	return s.upIncomeStatisDate(c, mids, typ, groupType, from, to)
+}
+
+func (s *Service) upStatisDaily(c context.Context, typ int, from, to time.Time) (data interface{}, err error) {
+	table, _ := getUpInfoByType(typ)
+	statis, err := s.dao.GetUpDailyStatis(c, table, from.Format(_layout), to.Format(_layout))
+	if err != nil {
+		log.Error("s.dao.GetIncomeDailyStatis error(%v)", err)
+		return
+	}
+	dateMap := make(map[string]*model.UpStatisRsp)
+	for _, sta := range statis {
+		date := sta.Date.Time().Format(_layout)
+		if val, ok := dateMap[date]; ok {
+			val.Ups += sta.Ups
+		} else {
+			dateMap[date] = &model.UpStatisRsp{
+				Income: sta.Income,
+				Ups:    sta.Ups,
+			}
+		}
+	}
+	data = calUpStatis(dateMap, 1, from, to)
+	return
+}
+
+func (s *Service) upIncomeStatisDate(c context.Context, mids []int64, typ, groupType int, from, to time.Time) (data interface{}, err error) {
+	table := setUpTableByGroup(groupType)
+	_, incomeType := getUpInfoByType(typ)
+	query := formatUpQuery(mids, from, to, incomeType)
+	upIncome, err := s.GetUpIncome(c, table, incomeType, query)
+	if err != nil {
+		log.Error("s.GetUpIncome error(%v)", err)
+		return
+	}
+
+	sort.Slice(upIncome, func(i, j int) bool {
+		return upIncome[i].Date < upIncome[j].Date
+	})
+
+	dateMap := make(map[string]*model.UpStatisRsp)
+	for _, up := range upIncome {
+		date := formatDateByGroup(up.Date.Time(), groupType)
+		if val, ok := dateMap[date]; ok {
+			val.Income += up.Income
+			val.Ups++
+		} else {
+			dateMap[date] = &model.UpStatisRsp{
+				Income: up.Income,
+				Ups:    1,
+			}
+		}
+	}
+	data = calUpStatis(dateMap, groupType, from, to)
+	return
+}
+
+func calUpStatis(dateMap map[string]*model.UpStatisRsp, groupType int, from, to time.Time) interface{} {
+	incomes, ups, xAxis := []string{}, []int{}, []string{}
+	to = to.AddDate(0, 0, 1)
+	for from.Before(to) {
+		dateStr := formatDateByGroup(from, groupType)
+		xAxis = append(xAxis, dateStr)
+		if val, ok := dateMap[dateStr]; ok {
+			incomes = append(incomes, fmt.Sprintf("%.2f", float64(val.Income)/float64(100)))
+			ups = append(ups, val.Ups)
+		} else {
+			incomes = append(incomes, "0")
+			ups = append(ups, 0)
+		}
+
+		from = addDayByGroup(groupType, from)
+	}
+
+	return map[string]interface{}{
+		"counts":  ups,
+		"incomes": incomes,
+		"xaxis":   xAxis,
+	}
+}
+
+// GetUpIncome get
+func (s *Service) GetUpIncome(c context.Context, table, incomeType, query string) (upIncomes []*model.UpIncome, err error) {
+	var id int64
+	limit := 2000
+	for {
+		upIncome, err := s.dao.GetUpIncome(c, table, incomeType, query, id, limit)
+		if err != nil {
+			return upIncomes, err
+		}
+		upIncomes = append(upIncomes, upIncome...)
+		if len(upIncome) < limit {
+			break
+		}
+		id = upIncome[len(upIncome)-1].ID
+	}
+	return
+}
+
+func formatUpQuery(mids []int64, fromTime, toTime time.Time, incomeType string) string {
+	query := "date >= '" + fromTime.Format("2006-01-02") + "'"
+	query += " AND "
+	query += "date <= '" + toTime.Format("2006-01-02") + "'"
+	if len(mids) != 0 {
+		query += " AND "
+		query += "mid in (" + xstr.JoinInts(mids) + ")"
+	}
+	query += fmt.Sprintf(" AND %s > 0", incomeType)
+	return query
+}

app/admin/main/growup/service/income/up_income_test.go

@@ -0,0 +1,51 @@
+package income
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_UpIncomeStatis(t *testing.T) {
+	Convey("UpIncomeStatis", t, WithService(func(s *Service) {
+		mids := []int64{}
+		groupType := 1
+		fromTime := time.Now().AddDate(0, -1, 0).Unix() * 1000
+		toTime := time.Now().Unix() * 1000
+		_, err := s.UpIncomeStatis(context.Background(), mids, 0, groupType, fromTime, toTime)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func Test_GetUpIncome(t *testing.T) {
+	Convey("GetUpIncome", t, WithService(func(s *Service) {
+		mids := []int64{}
+		fromTime := time.Now().AddDate(0, -1, 0)
+		toTime := time.Now()
+		query := formatUpQuery(mids, fromTime, toTime, "income")
+		_, err := s.GetUpIncome(context.Background(), "up_income", "income", query)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func BenchmarkUpIncomeStatis(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		mids := []int64{}
+		groupType := 1
+		fromTime := time.Now().AddDate(0, -1, 0).Unix() * 1000
+		toTime := time.Now().Unix() * 1000
+		s.UpIncomeStatis(context.Background(), mids, 0, groupType, fromTime, toTime)
+	}
+}
+
+func BenchmarkGetUpIncome(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		mids := []int64{}
+		fromTime := time.Now().AddDate(0, -1, 0)
+		toTime := time.Now()
+		query := formatUpQuery(mids, fromTime, toTime, "income")
+		s.GetUpIncome(context.Background(), "up_income", "income", query)
+	}
+}

app/admin/main/growup/service/income/up_info_video.go

@@ -0,0 +1,23 @@
+package income
+
+import (
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+// TxUpdateUpInfoScore update up_info_video score
+func (s *Service) TxUpdateUpInfoScore(tx *sql.Tx, mid int64, score int) (err error) {
+	_, err = s.dao.TxUpdateUpInfoScore(tx, "up_info_video", score, mid)
+	if err != nil {
+		tx.Rollback()
+		log.Error("s.dao.TxUpdateUpInfoScore error(%v)", err)
+		return err
+	}
+
+	_, err = s.dao.TxUpdateUpInfoScore(tx, "up_info_column", score, mid)
+	if err != nil {
+		tx.Rollback()
+		log.Error("s.dao.TxUpdateUpInfoScore error(%v)", err)
+	}
+	return
+}

app/admin/main/growup/service/income/up_info_video_test.go

@@ -0,0 +1,23 @@
+package income
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_UpInfoVideo(t *testing.T) {
+	Convey("update up_info_video score", t, WithService(func(s *Service) {
+		var (
+			mid   = int64(1101)
+			score = 100
+		)
+		tx, err := s.dao.BeginTran(context.Background())
+		So(err, ShouldBeNil)
+		err = s.TxUpdateUpInfoScore(tx, mid, score)
+		So(err, ShouldBeNil)
+		err = tx.Commit()
+		So(err, ShouldBeNil)
+	}))
+}

app/admin/main/growup/service/income/withdraw.go

@@ -0,0 +1,221 @@
+package income
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"time"
+
+	model "go-common/app/admin/main/growup/model/income"
+	"go-common/app/admin/main/growup/service"
+
+	"go-common/library/log"
+	"go-common/library/xstr"
+)
+
+// UpWithdraw get up_account infos
+func (s *Service) UpWithdraw(c context.Context, mids []int64, isDeleted, from, limit int) (data []*model.UpWithdrawRes, total int64, err error) {
+	query := ""
+	if len(mids) != 0 {
+		query += fmt.Sprintf("mid in (%s)", xstr.JoinInts(mids))
+	}
+	total, err = s.UpAccountCount(c, query, isDeleted)
+	if err != nil {
+		log.Error("s.UpAccountCount error(%v)", err)
+		return
+	}
+	ups, err := s.ListUpAccount(c, query, isDeleted, from, limit)
+	if err != nil {
+		log.Error("s.ListUpAccount error(%v)", err)
+		return
+	}
+
+	if len(mids) == 0 {
+		for _, up := range ups {
+			mids = append(mids, up.MID)
+		}
+	}
+	query = ""
+	if len(mids) != 0 {
+		query = fmt.Sprintf("mid in (%s)", xstr.JoinInts(mids))
+	}
+	upWithdraw, err := s.GetUpWithdraw(c, query)
+	if err != nil {
+		log.Error("s.GetUpWithdraw error(%v)", err)
+		return
+	}
+	withdrawMap := make(map[string]int64)
+	for _, w := range upWithdraw {
+		key := fmt.Sprintf("%d+%s", w.MID, w.DateVersion)
+		withdrawMap[key] = w.WithdrawIncome
+	}
+
+	upInfo, err := s.dao.ListUpInfo(c, mids)
+	if err != nil {
+		log.Error("s.dao.ListUpInfo error(%v)", err)
+		return
+	}
+
+	sort.Slice(ups, func(i, j int) bool {
+		return ups[i].LastWithdrawTime > ups[j].LastWithdrawTime
+	})
+
+	data = make([]*model.UpWithdrawRes, 0)
+	for _, up := range ups {
+		key := fmt.Sprintf("%d+%s", up.MID, up.WithdrawDateVersion)
+		data = append(data, &model.UpWithdrawRes{
+			MID:                up.MID,
+			Nickname:           upInfo[up.MID],
+			WithdrawIncome:     fmt.Sprintf("%0.2f", fromYuanToFen(up.TotalWithdrawIncome)),
+			UnWithdrawIncome:   fmt.Sprintf("%0.2f", fromYuanToFen(up.TotalUnwithdrawIncome)),
+			LastWithdrawIncome: fmt.Sprintf("%0.2f", fromYuanToFen(withdrawMap[key])),
+			WithdrawDate:       up.LastWithdrawTime.Time().Format(_layout),
+			MTime:              up.MTime,
+		})
+	}
+	return
+}
+
+// UpWithdrawExport export up withdraw
+func (s *Service) UpWithdrawExport(c context.Context, mids []int64, isDeleted, from, limit int) (res []byte, err error) {
+	upWithdraw, _, err := s.UpWithdraw(c, mids, isDeleted, from, limit)
+	if err != nil {
+		log.Error("s.UpWithdraw error(%v)", err)
+		return
+	}
+
+	records := formatUpWithdraw(upWithdraw, isDeleted)
+	res, err = service.FormatCSV(records)
+	if err != nil {
+		log.Error("FormatCSV error(%v)")
+	}
+	return
+}
+
+// GetUpWithdraw get up_withdraw
+func (s *Service) GetUpWithdraw(c context.Context, query string) (upW []*model.UpIncomeWithdraw, err error) {
+	upW = make([]*model.UpIncomeWithdraw, 0)
+	var id int64
+	limit := 2000
+	for {
+		var w []*model.UpIncomeWithdraw
+		w, err = s.ListUpWithdraw(c, id, query, limit)
+		if err != nil {
+			return
+		}
+		upW = append(upW, w...)
+		if len(w) < limit {
+			break
+		}
+		id = w[len(w)-1].ID
+	}
+	return
+}
+
+// ListUpWithdraw list up_withdraw
+func (s *Service) ListUpWithdraw(c context.Context, id int64, query string, limit int) (upWithdraw []*model.UpIncomeWithdraw, err error) {
+	if query != "" {
+		query += " AND"
+	}
+	return s.dao.ListUpWithdraw(c, id, query, limit)
+}
+
+// UpWithdrawStatis up_withdraw statis
+func (s *Service) UpWithdrawStatis(c context.Context, from, to int64, isDeleted int) (data interface{}, err error) {
+	now := time.Now()
+	var fromTime, toTime time.Time
+	if from == 0 || to == 0 {
+		fromTime = time.Date(now.Year()-1, now.Month(), 1, 0, 0, 0, 0, time.Local)
+		toTime = time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, time.Local)
+	} else {
+		fromTime = time.Unix(from, 0)
+		toTime = time.Unix(to, 0)
+	}
+	query := fmt.Sprintf("date_version >= '%s' and date_version <= '%s'", fromTime.Format(_layoutMonth), toTime.Format(_layoutMonth))
+	upWithdraw, err := s.GetUpWithdraw(c, query)
+	if err != nil {
+		log.Error("s.GetUpWithdraw error(%v)", err)
+		return
+	}
+
+	deletedUp, err := s.GetUpAccount(c, "", 1)
+	if err != nil {
+		log.Error("s.GetUpAccount error(%v)", err)
+		return
+	}
+	deletedUpMap := make(map[int64]struct{})
+	for _, up := range deletedUp {
+		deletedUpMap[up.MID] = struct{}{}
+	}
+
+	data = upWithdrawStatis(upWithdraw, deletedUpMap, isDeleted, fromTime, toTime)
+	return
+}
+
+func upWithdrawStatis(upWithdraw []*model.UpIncomeWithdraw, deletedUp map[int64]struct{}, isDeleted int, startTime, endTime time.Time) interface{} {
+	dateCount := make(map[string]int)
+	dateIncome := make(map[string]int64)
+	for _, up := range upWithdraw {
+		_, ok := deletedUp[up.MID]
+		if (ok && isDeleted == 1) || (!ok && isDeleted == 0) {
+			dateCount[up.DateVersion]++
+			dateIncome[up.DateVersion] += up.WithdrawIncome
+		}
+	}
+
+	incomes, counts, xAxis := []string{}, []int{}, []string{}
+	endTime = endTime.AddDate(0, 0, 1)
+	for startTime.Before(endTime) {
+		key := startTime.Format(_layoutMonth)
+		incomes = append(incomes, fmt.Sprintf("%0.2f", fromYuanToFen(dateIncome[key])))
+		counts = append(counts, dateCount[key])
+		xAxis = append(xAxis, key)
+		startTime = startTime.AddDate(0, 1, 0)
+	}
+
+	return map[string]interface{}{
+		"incomes": incomes,
+		"counts":  counts,
+		"xaxis":   xAxis,
+	}
+}
+
+// UpWithdrawDetail get up withdraw by mid
+func (s *Service) UpWithdrawDetail(c context.Context, mid int64) (upWithdraw []*model.UpIncomeWithdraw, err error) {
+	query := fmt.Sprintf("mid = %d", mid)
+	upWithdraw, err = s.GetUpWithdraw(c, query)
+	if err != nil {
+		log.Error("s.GetUpWithdraw error(%v)", err)
+		return
+	}
+	if len(upWithdraw) == 0 {
+		return
+	}
+
+	upInfo, err := s.dao.GetUpInfoNickname(c, []int64{upWithdraw[0].MID})
+	if err != nil {
+		log.Error("s.dao.GetUpInfoNickname error(%v)", err)
+		return
+	}
+	for _, up := range upWithdraw {
+		up.Nickname = upInfo[up.MID]
+		up.Income = fmt.Sprintf("%.2f", fromYuanToFen(up.WithdrawIncome))
+	}
+	return
+}
+
+// UpWithdrawDetailExport export up withdraw detail
+func (s *Service) UpWithdrawDetailExport(c context.Context, mid int64) (res []byte, err error) {
+	upWithdraw, err := s.UpWithdrawDetail(c, mid)
+	if err != nil {
+		log.Error("s.UpWithdrawDetail error(%v)", err)
+		return
+	}
+
+	records := formatUpIncomeWithdraw(upWithdraw)
+	res, err = service.FormatCSV(records)
+	if err != nil {
+		log.Error("FormatCSV error(%v)")
+	}
+	return
+}

app/admin/main/growup/service/income/withdraw_test.go

@@ -0,0 +1,90 @@
+package income
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_UpWithdraw(t *testing.T) {
+	Convey("UpWithdraw", t, WithService(func(s *Service) {
+		var (
+			mids        = []int64{int64(1101)}
+			isDeleted   = 1
+			from, limit = 0, 1000
+		)
+		res, _, err := s.UpWithdraw(context.Background(), mids, isDeleted, from, limit)
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}
+
+func Test_UpWithdrawExport(t *testing.T) {
+	Convey("UpWithdrawExport", t, WithService(func(s *Service) {
+		var (
+			mids        = []int64{int64(1101)}
+			isDeleted   = 1
+			from, limit = 0, 1000
+		)
+		res, err := s.UpWithdrawExport(context.Background(), mids, isDeleted, from, limit)
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}
+
+func Test_GetUpWithdraw(t *testing.T) {
+	Convey("GetUpWithdraw", t, WithService(func(s *Service) {
+		var (
+			query = ""
+		)
+		res, err := s.GetUpWithdraw(context.Background(), query)
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}
+
+func Test_ListUpWithdraw(t *testing.T) {
+	Convey("ListUpWithdraw", t, WithService(func(s *Service) {
+		var (
+			id    int64
+			query = ""
+			limit = 500
+		)
+		res, err := s.ListUpWithdraw(context.Background(), id, query, limit)
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}
+
+func Test_UpWithdrawStatis(t *testing.T) {
+	Convey("UpWithdrawStatis", t, WithService(func(s *Service) {
+		var (
+			isDeleted = 0
+		)
+		_, err := s.UpWithdrawStatis(context.Background(), 1522512000, 1533052800, isDeleted)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func Test_UpWithdrawDetail(t *testing.T) {
+	Convey("UpWithdrawDetail", t, WithService(func(s *Service) {
+		var (
+			mid int64 = 50
+		)
+		res, err := s.UpWithdrawDetail(context.Background(), mid)
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}
+
+func Test_UpWithdrawDetailExport(t *testing.T) {
+	Convey("UpWithdrawDetailExport", t, WithService(func(s *Service) {
+		var (
+			mid int64 = 50
+		)
+		res, err := s.UpWithdrawDetailExport(context.Background(), mid)
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}