Initial commit

app/admin/main/feed/service/BUILD

@@ -0,0 +1,27 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/admin/main/feed/service/bfs:all-srcs",
+        "//app/admin/main/feed/service/channel:all-srcs",
+        "//app/admin/main/feed/service/common:all-srcs",
+        "//app/admin/main/feed/service/egg:all-srcs",
+        "//app/admin/main/feed/service/pgc:all-srcs",
+        "//app/admin/main/feed/service/popular:all-srcs",
+        "//app/admin/main/feed/service/search:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/main/feed/service/bfs/BUILD

@@ -0,0 +1,33 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["bfs.go"],
+    importpath = "go-common/app/admin/main/feed/service/bfs",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/feed/conf:go_default_library",
+        "//app/admin/main/feed/dao/bfs:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log: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/feed/service/bfs/bfs.go

@@ -0,0 +1,48 @@
+package bfs
+
+import (
+	"bytes"
+	"context"
+
+	"go-common/app/admin/main/feed/conf"
+	bfsdao "go-common/app/admin/main/feed/dao/bfs"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+// Service bfs service.
+type Service struct {
+	dao        *bfsdao.Dao
+	BfsMaxSize int
+}
+
+// New new a bfs service.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		dao:        bfsdao.New(c),
+		BfsMaxSize: c.Bfs.MaxFileSize,
+	}
+	return
+}
+
+// ClientUpCover client upload cover.
+func (s *Service) ClientUpCover(c context.Context, fileType string, body []byte) (url string, err error) {
+	if len(body) == 0 {
+		err = ecode.FileNotExists
+		return
+	}
+	if len(body) > s.BfsMaxSize {
+		err = ecode.FileTooLarge
+		return
+	}
+	url, err = s.dao.Upload(c, fileType, bytes.NewReader(body))
+	if err != nil {
+		log.Error("s.bfs.Upload error(%v)", err)
+	}
+	return
+}
+
+// FileMd5 is used for calculating file md5.
+func (s *Service) FileMd5(content []byte) (md5Str string, err error) {
+	return s.dao.FileMd5(content)
+}

app/admin/main/feed/service/channel/BUILD

@@ -0,0 +1,41 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "card_setup.go",
+        "tab.go",
+    ],
+    importpath = "go-common/app/admin/main/feed/service/channel",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/feed/conf:go_default_library",
+        "//app/admin/main/feed/dao/account:go_default_library",
+        "//app/admin/main/feed/dao/archive:go_default_library",
+        "//app/admin/main/feed/dao/pgc:go_default_library",
+        "//app/admin/main/feed/dao/show:go_default_library",
+        "//app/admin/main/feed/model/channel:go_default_library",
+        "//app/admin/main/feed/model/common:go_default_library",
+        "//app/admin/main/feed/model/show:go_default_library",
+        "//app/admin/main/feed/util:go_default_library",
+        "//library/log: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/feed/service/channel/card_setup.go

@@ -0,0 +1,229 @@
+package channel
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+
+	"go-common/app/admin/main/feed/conf"
+	accdao "go-common/app/admin/main/feed/dao/account"
+	arcdao "go-common/app/admin/main/feed/dao/archive"
+	pgcdao "go-common/app/admin/main/feed/dao/pgc"
+	showdao "go-common/app/admin/main/feed/dao/show"
+	cardmodel "go-common/app/admin/main/feed/model/channel"
+	"go-common/app/admin/main/feed/model/common"
+	"go-common/app/admin/main/feed/util"
+	"go-common/library/log"
+)
+
+// Service is search service
+type Service struct {
+	showDao *showdao.Dao
+	pgcDao  *pgcdao.Dao
+	accDao  *accdao.Dao
+	arcDao  *arcdao.Dao
+}
+
+// New new a search service
+func New(c *conf.Config) (s *Service) {
+	var (
+		pgc *pgcdao.Dao
+		err error
+	)
+	if pgc, err = pgcdao.New(c); err != nil {
+		log.Error("pgcdao.New error(%v)", err)
+		return
+	}
+	s = &Service{
+		showDao: showdao.New(c),
+		pgcDao:  pgc,
+		accDao:  accdao.New(c),
+		arcDao:  arcdao.New(c),
+	}
+	return
+}
+
+//parseConten parse string type id to int type id
+func parseConten(content string) (s string, err error) {
+	type Content struct {
+		ID    string `json:"id"`
+		Title string `json:"title"`
+	}
+	var contents []Content
+	if err = json.Unmarshal([]byte(content), &contents); err != nil {
+		return
+	}
+	type ContentTrans struct {
+		ID    int64  `json:"id"`
+		Title string `json:"title"`
+	}
+	var cTrans []ContentTrans
+	for _, v := range contents {
+		var s int64
+		if s, err = strconv.ParseInt(v.ID, 10, 64); err != nil {
+			return "", err
+		}
+		v := ContentTrans{
+			ID:    s,
+			Title: v.Title,
+		}
+		cTrans = append(cTrans, v)
+	}
+	var b []byte
+	if b, err = json.Marshal(cTrans); err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+//AddCardSetup card set up
+func (s *Service) AddCardSetup(card *cardmodel.AddCardSetup, person string, uid int64) (err error) {
+	var (
+		flag bool
+		e    error
+	)
+	flag, e = isDup(card.Content)
+	if e != nil {
+		return e
+	}
+	if flag {
+		return fmt.Errorf("ID重复")
+	}
+	card.Person = person
+	card.UID = uid
+	if card.Content, err = parseConten(card.Content); err != nil {
+		return
+	}
+	if err = s.showDao.DB.Model(&cardmodel.AddCardSetup{}).
+		Create(card).Error; err != nil {
+		log.Error("chanelSvc.AddCardSetup Create error(%v)", err)
+		return
+	}
+	if card.Type == common.CardPgcsRcmd {
+		if err = util.AddLog(cardmodel.LogBusPgcsRcmd, person, uid, 0, cardmodel.ActAddCsPgcRcmd, card); err != nil {
+			log.Error("chanelSvc.UpdateCardSetup AddLog error(%v)", err)
+			return
+		}
+	} else if card.Type == common.CardUpRcmdNew {
+		if err = util.AddLog(cardmodel.LogBusRcmdNew, person, uid, 0, cardmodel.ActAddCsRcmdNew, card); err != nil {
+			log.Error("chanelSvc.UpdateCardSetup AddLog error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+//CardSetupList card set up
+func (s *Service) CardSetupList(id int, t string, person string, title string, pn int, ps int) (cPager *cardmodel.SetupPager, err error) {
+	cPager = &cardmodel.SetupPager{
+		Page: common.Page{
+			Num:  pn,
+			Size: ps,
+		},
+	}
+	w := map[string]interface{}{
+		"deleted": cardmodel.NotDelete,
+		"type":    t,
+	}
+	query := s.showDao.DB.Model(&cardmodel.Setup{})
+	if id != 0 {
+		w["id"] = id
+	}
+	if person != "" {
+		query = query.Where("person like ?", "%"+person+"%")
+	}
+	if title != "" {
+		if t == "up_rcmd_new" {
+			query = query.Where("long_title like ?", "%"+title+"%")
+		} else {
+			query = query.Where("title like ?", "%"+title+"%")
+		}
+	}
+	if err = query.Where(w).Count(&cPager.Page.Total).Error; err != nil {
+		log.Error("chanelSvc.CardSetupList Index count error(%v)", err)
+		return
+	}
+	cards := []*cardmodel.Setup{}
+	if err = query.Where(w).Order("`id` DESC").Offset((pn - 1) * ps).Limit(ps).Find(&cards).Error; err != nil {
+		log.Error("chanelSvc.CardSetupList First error(%v)", err)
+		return
+	}
+	cPager.Item = cards
+	return
+}
+
+//DelCardSetup card set up
+func (s *Service) DelCardSetup(id int, t string, person string, uid int64) (err error) {
+	dbModel := s.showDao.DB.Model(&cardmodel.Setup{})
+	dbModel = dbModel.Where("id = ?", id).Where("type = ?", t)
+	if err = dbModel.Update("deleted", cardmodel.Delete).Error; err != nil {
+		log.Error("chanelSvc.CardSetupList First error(%v)", err)
+		return
+	}
+	if t == common.CardPgcsRcmd {
+		if err = util.AddLog(cardmodel.LogBusPgcsRcmd, person, uid, int64(id), cardmodel.ActDelCsPgcRcmd, ""); err != nil {
+			log.Error("chanelSvc.UpdateCardSetup AddLog error(%v)", err)
+			return
+		}
+	} else if t == common.CardUpRcmdNew {
+		if err = util.AddLog(cardmodel.LogBusRcmdNew, person, uid, int64(id), cardmodel.ActDelCsRcmdNew, ""); err != nil {
+			log.Error("chanelSvc.UpdateCardSetup AddLog error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+func isDup(con string) (flag bool, err error) {
+	type Content struct {
+		ID string `json:"id"`
+	}
+	value := []Content{}
+	if err := json.Unmarshal([]byte(con), &value); err != nil {
+		return false, err
+	}
+	s := make(map[string]bool)
+	for _, v := range value {
+		if s[v.ID] {
+			return true, nil
+		}
+		s[v.ID] = true
+	}
+	return false, nil
+}
+
+//UpdateCardSetup card set up
+func (s *Service) UpdateCardSetup(id int, card *cardmodel.AddCardSetup, person string, uid int64) (err error) {
+	var (
+		flag bool
+		e    error
+	)
+	flag, e = isDup(card.Content)
+	if e != nil {
+		return e
+	}
+	if flag {
+		return fmt.Errorf("ID重复")
+	}
+	if card.Content, err = parseConten(card.Content); err != nil {
+		return
+	}
+	dbModel := s.showDao.DB.Model(&cardmodel.Setup{})
+	dbModel = dbModel.Where("id = ?", id).Where("type = ?", card.Type)
+	if err = dbModel.Update(card).Error; err != nil {
+		log.Error("chanelSvc.CardSetupList First error(%v)", err)
+		return
+	}
+	if card.Type == common.CardPgcsRcmd {
+		if err = util.AddLog(cardmodel.LogBusPgcsRcmd, person, uid, int64(id), cardmodel.ActUpCsPgcRcmd, card); err != nil {
+			log.Error("chanelSvc.UpdateCardSetup AddLog error(%v)", err)
+			return
+		}
+	} else if card.Type == common.CardUpRcmdNew {
+		if err = util.AddLog(cardmodel.LogBusRcmdNew, person, uid, int64(id), cardmodel.ActUpCsRcmdNew, card); err != nil {
+			log.Error("chanelSvc.UpdateCardSetup AddLog error(%v)", err)
+			return
+		}
+	}
+	return
+}

app/admin/main/feed/service/channel/tab.go

@@ -0,0 +1,223 @@
+package channel
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/admin/main/feed/model/common"
+	"go-common/app/admin/main/feed/model/show"
+	"go-common/app/admin/main/feed/util"
+	"go-common/library/log"
+)
+
+const (
+	//TabOnline channel tab online
+	TabOnline = 1
+	//TabDownline channel tab down line
+	TabDownline = 2
+	//TabWaitOnline channel tab wait to line
+	TabWaitOnline = 3
+	//OrderTimeDown channel tab oder by stime desc
+	OrderTimeDown = 1
+	//OrderTimeUp channel tab oder by stime asc
+	OrderTimeUp = 2
+	//ActionAddCTab log action
+	ActionAddCTab = "ActAddChannelTab"
+	//ActionUpCTab log action
+	ActionUpCTab = "ActUpChannelTab"
+	//ActionDelCTab log action
+	ActionDelCTab = "ActDelChannelTab"
+	//ActionOfflineCTab log action
+	ActionOfflineCTab = "ActOfflineChannelTab"
+)
+
+//TabList channel tab list
+func (s *Service) TabList(lp *show.ChannelTabLP) (pager *show.ChannelTabPager, err error) {
+	var (
+		eTime int64
+		sTime int64
+	)
+	pager = &show.ChannelTabPager{
+		Page: common.Page{
+			Num:  lp.Pn,
+			Size: lp.Ps,
+		},
+	}
+	w := map[string]interface{}{
+		"is_delete": common.NotDeleted,
+	}
+	query := s.showDao.DB.Model(&show.ChannelTab{})
+	if lp.TagID > 0 {
+		w["tag_id"] = lp.TagID
+	}
+	if lp.TabID > 0 {
+		w["tab_id"] = lp.TabID
+	}
+	if lp.Stime > 0 {
+		query = query.Where("stime >= ?", lp.Stime)
+	}
+	if lp.Etime > 0 {
+		query = query.Where("etime <= ?", lp.Etime)
+	}
+	if lp.Person != "" {
+		query = query.Where("person like ?", "%"+lp.Person+"%")
+	}
+	if lp.Status == TabWaitOnline {
+		if lp.Stime != 0 {
+			if lp.Stime < time.Now().Unix() {
+				sTime = time.Now().Unix()
+			} else {
+				sTime = lp.Stime
+			}
+		} else {
+			sTime = time.Now().Unix()
+		}
+		query = query.Where("stime >= ?", sTime)
+	} else if lp.Status == TabOnline {
+		if lp.Stime != 0 {
+			if lp.Stime < time.Now().Unix() {
+				sTime = time.Now().Unix()
+			} else {
+				sTime = lp.Stime
+			}
+		} else {
+			sTime = time.Now().Unix()
+		}
+		if lp.Etime != 0 {
+			if lp.Etime > time.Now().Unix() {
+				eTime = time.Now().Unix()
+			} else {
+				eTime = lp.Etime
+			}
+		} else {
+			eTime = time.Now().Unix()
+		}
+		query = query.Where("stime < ?", sTime).Where("etime >= ?", eTime)
+	} else if lp.Status == TabDownline {
+		if lp.Etime != 0 {
+			if lp.Etime < time.Now().Unix() {
+				eTime = lp.Etime
+			} else {
+				eTime = time.Now().Unix()
+			}
+		} else {
+			eTime = time.Now().Unix()
+		}
+		query = query.Where("etime < ?", eTime)
+	}
+	if lp.Order == OrderTimeDown {
+		query = query.Order("`stime` ASC")
+	} else if lp.Order == OrderTimeUp {
+		query = query.Order("`stime` DESC")
+	}
+	if err = query.Where(w).Count(&pager.Page.Total).Error; err != nil {
+		log.Error("chanelSvc.CardSetupList Index count error(%v)", err)
+		return
+	}
+
+	tabs := []*show.ChannelTab{}
+	if err = query.Where(w).Order("`id` DESC").Offset((lp.Pn - 1) * lp.Ps).Limit(lp.Ps).Find(&tabs).Error; err != nil {
+		log.Error("chanelSvc.CardSetupList First error(%v)", err)
+		return
+	}
+	for k, v := range tabs {
+		//online for fe
+		if time.Now().Unix() < v.Stime {
+			tabs[k].Status = TabWaitOnline
+		} else if time.Now().Unix() >= v.Etime {
+			tabs[k].Status = TabDownline
+		} else {
+			tabs[k].Status = TabOnline
+		}
+	}
+	pager.Item = tabs
+	return
+}
+
+//AddTab add channel tab
+func (s *Service) AddTab(c context.Context, param *show.ChannelTabAP, name string, uid int64) (err error) {
+	if err = s.IsValid(0, param.TagID, param.Stime, param.Etime, param.Priority); err != nil {
+		return
+	}
+	if err = s.showDao.ChannelTabAdd(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogChannelTab, name, uid, 0, ActionAddCTab, param); err != nil {
+		log.Error("chanelSvc.AddTab AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//IsValid validate data
+func (s *Service) IsValid(id, tagID, sTime int64, eTime int64, priority int) (err error) {
+	var (
+		count int
+	)
+	if sTime > eTime {
+		err = fmt.Errorf("开始时间不能大于结束时间")
+		return
+	}
+	if sTime < time.Now().Unix() {
+		err = fmt.Errorf("生效时间需要大于当前时间")
+		return
+	}
+	if count, err = s.showDao.ChannelTabValid(id, tagID, sTime, eTime, priority); err != nil {
+		return
+	}
+	if count > 0 {
+		err = fmt.Errorf("已有该排序无法创建，请重新选择")
+		return
+	}
+	if count, err = s.showDao.ChannelTabValid(id, tagID, sTime, eTime, 0); err != nil {
+		return
+	}
+	if count >= 3 {
+		stimeStr := time.Unix(sTime, 0).Format("2006-01-02 15:04:05")
+		etimeStr := time.Unix(eTime, 0).Format("2006-01-02 15:04:05")
+		str := "频道在" + stimeStr + " 至 " + etimeStr + " 时间段内已有3个运营tab，无法创建"
+		err = fmt.Errorf(str)
+		return
+	}
+	return
+}
+
+//UpdateTab update channel tab
+func (s *Service) UpdateTab(c context.Context, param *show.ChannelTabUP, name string, uid int64) (err error) {
+	if err = s.IsValid(param.ID, param.TagID, param.Stime, param.Etime, param.Priority); err != nil {
+		return
+	}
+	if err = s.showDao.ChannelTabUpdate(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogChannelTab, name, uid, 0, ActionUpCTab, param); err != nil {
+		log.Error("chanelSvc.UpdateTab AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//DeleteTab delete channel tab
+func (s *Service) DeleteTab(id int64, name string, uid int64) (err error) {
+	if err = s.showDao.ChannelTabDelete(id); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogChannelTab, name, uid, id, ActionDelCTab, id); err != nil {
+		log.Error("chanelSvc.DeleteTab AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//OfflineTab offline channel tab
+func (s *Service) OfflineTab(id int64, name string, uid int64) (err error) {
+	if err = s.showDao.ChannelTabOffline(id); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogChannelTab, name, uid, id, ActionOfflineCTab, id); err != nil {
+		log.Error("chanelSvc.DeleteTab AddLog error(%v)", err)
+		return
+	}
+	return
+}

app/admin/main/feed/service/common/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cardpreview.go",
+        "cardtype.go",
+        "common.go",
+        "log.go",
+    ],
+    importpath = "go-common/app/admin/main/feed/service/common",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/feed/conf:go_default_library",
+        "//app/admin/main/feed/dao/account:go_default_library",
+        "//app/admin/main/feed/dao/archive:go_default_library",
+        "//app/admin/main/feed/dao/pgc:go_default_library",
+        "//app/admin/main/feed/dao/show:go_default_library",
+        "//app/admin/main/feed/model/common:go_default_library",
+        "//app/admin/main/feed/model/show:go_default_library",
+        "//app/admin/main/search/model:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/openplatform/pgc-season/api/grpc/season/v1:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster: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/feed/service/common/cardpreview.go

@@ -0,0 +1,79 @@
+package common
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/admin/main/feed/model/common"
+	showModel "go-common/app/admin/main/feed/model/show"
+	account "go-common/app/service/main/account/model"
+	"go-common/app/service/main/archive/api"
+	seasondao "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
+	"go-common/library/ecode"
+)
+
+//CardPreview card preview
+func (s *Service) CardPreview(c context.Context, cType string, id int64) (title string, err error) {
+	var (
+		accCard    *account.Card
+		appActive  *showModel.AppActive
+		eventTopic *showModel.EventTopic
+		webCard    *showModel.SearchWebCard
+		seaCards   map[int32]*seasondao.CardInfoProto
+		arcCard    *api.Arc
+	)
+	switch cType {
+	case common.CardPgc:
+		v := []int32{int32(id)}
+		if seaCards, err = s.pgcDao.CardsInfoReply(c, v); err != nil {
+			return
+		}
+		if v, ok := seaCards[int32(id)]; ok {
+			return v.Title, nil
+		}
+		return "", fmt.Errorf("无效pgc卡片ID(%d)", id)
+	case common.CardAv:
+		if arcCard, err = s.arcDao.Archive3(c, id); err != nil {
+			if err.Error() == ecode.NothingFound.Error() {
+				return "", fmt.Errorf("无效稿件ID(%d)", id)
+			}
+			return
+		}
+		return arcCard.Title, nil
+	case common.CardUp:
+		if accCard, err = s.accDao.Card3(c, id); err != nil {
+			if err.Error() == ecode.MemberNotExist.Error() {
+				return "", fmt.Errorf("无效up主ID(%d)", id)
+			}
+			return
+		}
+		return accCard.Name, nil
+	case common.CardChannelTab:
+		if appActive, err = s.showDao.AAFindByID(c, int64(id)); err != nil {
+			return "", err
+		}
+		if appActive == nil {
+			return "", fmt.Errorf("无效tab卡片ID(%d)", id)
+		}
+		return appActive.Name, nil
+	case common.CardEventTopic:
+		if eventTopic, err = s.showDao.ETFindByID(id); err != nil {
+			return "", err
+		}
+		if eventTopic == nil {
+			return "", fmt.Errorf("无效事件专题卡片ID(%d)", id)
+		}
+		return eventTopic.Title, nil
+	case common.CardSearchWeb:
+		if webCard, err = s.showDao.SWBFindByID(id); err != nil {
+			return "", err
+		}
+		if webCard == nil {
+			return "", fmt.Errorf("无效web卡片ID(%d)", id)
+		}
+		return webCard.Title, nil
+	default:
+		err = fmt.Errorf("参数错误")
+		return "", err
+	}
+}

app/admin/main/feed/service/common/cardtype.go

@@ -0,0 +1,25 @@
+package common
+
+//CardMap .
+type CardMap struct {
+	Name string `json:"name"`
+	ID   int    `json:"id"`
+}
+
+//WebSearch .
+type WebSearch struct {
+	CardList []*CardMap `json:"web_search"`
+}
+
+//CardType .
+func (s *Service) CardType() (m *WebSearch) {
+	c := &CardMap{
+		Name: "特殊小卡",
+		ID:   1,
+	}
+	cards := make([]*CardMap, 0)
+	cards = append(cards, c)
+	return &WebSearch{
+		CardList: cards,
+	}
+}

app/admin/main/feed/service/common/common.go

@@ -0,0 +1,42 @@
+package common
+
+import (
+	"go-common/app/admin/main/feed/conf"
+	accdao "go-common/app/admin/main/feed/dao/account"
+	arcdao "go-common/app/admin/main/feed/dao/archive"
+	pgcdao "go-common/app/admin/main/feed/dao/pgc"
+	showdao "go-common/app/admin/main/feed/dao/show"
+	"go-common/library/log"
+	httpx "go-common/library/net/http/blademaster"
+)
+
+// Service is search service
+type Service struct {
+	showDao    *showdao.Dao
+	pgcDao     *pgcdao.Dao
+	accDao     *accdao.Dao
+	arcDao     *arcdao.Dao
+	client     *httpx.Client
+	managerURL string
+}
+
+// New new a search service
+func New(c *conf.Config) (s *Service) {
+	var (
+		pgc *pgcdao.Dao
+		err error
+	)
+	if pgc, err = pgcdao.New(c); err != nil {
+		log.Error("pgcdao.New error(%v)", err)
+		return
+	}
+	s = &Service{
+		showDao:    showdao.New(c),
+		pgcDao:     pgc,
+		accDao:     accdao.New(c),
+		arcDao:     arcdao.New(c),
+		client:     httpx.NewClient(c.HTTPClient),
+		managerURL: c.Host.Manager,
+	}
+	return
+}

app/admin/main/feed/service/common/log.go

@@ -0,0 +1,72 @@
+package common
+
+import (
+	"encoding/json"
+	"net/url"
+	"strconv"
+
+	"go-common/app/admin/main/feed/model/common"
+	searchModel "go-common/app/admin/main/search/model"
+	bm "go-common/library/net/http/blademaster"
+)
+
+const (
+	logURL = "/x/admin/search/log"
+)
+
+//LogAction log action
+func (s *Service) LogAction(c *bm.Context, typ, ps, pn int64, ctimeFrom, ctimeTo, uName string) (res *common.LogManagers, err error) {
+	var (
+		items []*common.LogManager
+	)
+	res = &common.LogManagers{}
+	params := url.Values{}
+	params.Set("appid", "log_audit")
+	params.Set("business", strconv.FormatUint(common.BusinessID, 10))
+	params.Set("order", "ctime")
+	params.Set("type", strconv.FormatInt(typ, 10))
+	params.Set("ps", strconv.FormatInt(ps, 10))
+	params.Set("pn", strconv.FormatInt(pn, 10))
+	if ctimeFrom != "" {
+		params.Set("ctime_from", ctimeFrom)
+	}
+	if ctimeTo != "" {
+		params.Set("ctime_to", ctimeTo)
+	}
+	if uName != "" {
+		params.Set("uname", uName)
+	}
+	type log struct {
+		Code int                       `json:"code"`
+		Data *searchModel.SearchResult `json:"data"`
+	}
+	l := &log{}
+	if err = s.client.Get(c, s.managerURL+logURL, "", params, l); err != nil {
+		return
+	}
+	var logS []*common.LogSearch
+	for _, v := range l.Data.Result {
+		log := &common.LogSearch{}
+		if err = json.Unmarshal(v, log); err != nil {
+			return
+		}
+		logS = append(logS, log)
+	}
+	for _, v := range logS {
+		tmp := &common.LogManager{
+			OID:       v.OID,
+			Uname:     v.Uname,
+			UID:       v.UID,
+			Type:      v.Type,
+			ExtraData: v.ExtraData,
+			Action:    v.Action,
+			CTime:     v.CTime,
+		}
+		items = append(items, tmp)
+	}
+	res.Item = items
+	res.Page.TotalItems = int(l.Data.Page.Total)
+	res.Page.PageSize = l.Data.Page.Ps
+	res.Page.CurrentPage = l.Data.Page.Pn
+	return
+}

app/admin/main/feed/service/egg/BUILD

@@ -0,0 +1,37 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["egg.go"],
+    importpath = "go-common/app/admin/main/feed/service/egg",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/feed/conf:go_default_library",
+        "//app/admin/main/feed/dao/egg:go_default_library",
+        "//app/admin/main/feed/model/common:go_default_library",
+        "//app/admin/main/feed/model/egg:go_default_library",
+        "//app/admin/main/feed/util:go_default_library",
+        "//library/log:go_default_library",
+        "//library/time: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/feed/service/egg/egg.go

@@ -0,0 +1,397 @@
+package egg
+
+import (
+	"time"
+
+	"go-common/app/admin/main/feed/conf"
+	"go-common/app/admin/main/feed/dao/egg"
+	"go-common/app/admin/main/feed/model/common"
+	eggModel "go-common/app/admin/main/feed/model/egg"
+	Log "go-common/app/admin/main/feed/util"
+	"go-common/library/log"
+	libTime "go-common/library/time"
+)
+
+const (
+	//_ActionAdd log action add
+	_ActionAdd = "add"
+	//_ActionUpdate log action update
+	_ActionUpdate = "update"
+	//_ActionDel log action delete
+	_ActionDel = "delete"
+	//_ActionPub log action publish
+	_ActionPub = "publish"
+)
+
+// Service is egg service
+type Service struct {
+	dao *egg.Dao
+}
+
+// New new a egg service
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		dao: egg.New(c),
+	}
+	return
+}
+
+//EggWithID get egg with ID
+func (s *Service) EggWithID(id uint) (egg *eggModel.Egg, err error) {
+	egg = &eggModel.Egg{}
+	if err = s.dao.DB.Model(&eggModel.Egg{}).Where("id = ?", id).
+		Where("`delete` != ?", eggModel.Delete).First(egg).
+		Error; err != nil {
+		log.Error("eggSrv.DelEgg Update error(%v)", err)
+		return
+	}
+	return
+}
+
+//DelEgg update egg
+func (s *Service) DelEgg(id uint, person string, uid int64) (err error) {
+	tx := s.dao.DB.Begin()
+	if err = tx.Model(&eggModel.Egg{}).Where("id = ?", id).Update("delete", eggModel.Delete).Error; err != nil {
+		log.Error("eggSrv.DelEgg Update error(%v)", err)
+		return
+	}
+	if err = tx.Model(&eggModel.Query{}).Where("egg_id = ?", id).Update("deleted", eggModel.Delete).Error; err != nil {
+		log.Error("eggSrv.DelEgg UpdateQuery error(%v)", err)
+		return
+	}
+	tx.Commit()
+	if err = Log.AddLog(eggModel.Business, person, uid, int64(id), _ActionDel, ""); err != nil {
+		log.Error("eggSrv.AddEgg AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//PubEgg publish egg
+func (s *Service) PubEgg(id uint, publish uint8, person string, uid int64) (err error) {
+	if err = s.dao.DB.Model(&eggModel.Egg{}).Where("id = ?", id).Update("publish", publish).Error; err != nil {
+		log.Error("eggSrv.PubEgg Update error(%v)", err)
+		return
+	}
+	if err = Log.AddLog(eggModel.Business, person, uid, int64(id), _ActionPub, ""); err != nil {
+		log.Error("eggSrv.PubEgg AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//UpdateEgg update egg
+func (s *Service) UpdateEgg(e *eggModel.Egg, p []eggModel.Plat, w []string) (err error) {
+	tx := s.dao.DB.Begin()
+	db := tx.Model(&eggModel.Egg{}).Where("id = ?", e.ID).Update(e)
+	if err = db.Error; err != nil {
+		log.Error("eggSrv.UpdateEgg UpdateEgg egg error(%v)", err)
+		return
+	}
+	db = tx.Model(&eggModel.Plat{}).Where("egg_id = ?", e.ID).Update("deleted", eggModel.Delete)
+	if err = db.Error; err != nil {
+		log.Error("eggSrv.UpdateEgg UpdatePlat error(%v)", err)
+		return
+	}
+	db = tx.Model(&eggModel.Query{}).Where("egg_id = ?", e.ID).Update("deleted", eggModel.Delete)
+	if err = db.Error; err != nil {
+		log.Error("eggSrv.UpdateEgg UpdateQuery error(%v)", err)
+		return
+	}
+	for _, v := range p {
+		v.EggID = e.ID
+		v.Deleted = eggModel.NotDelete
+		db := tx.Model(&eggModel.Plat{}).Create(v)
+		if err = db.Error; err != nil {
+			log.Error("eggSrv.UpdateEgg create egg plat error(%v)", err)
+			return
+		}
+	}
+	for _, v := range w {
+		q := eggModel.Query{
+			Word:    v,
+			EggID:   e.ID,
+			STime:   e.Stime,
+			ETime:   e.Etime,
+			Deleted: eggModel.NotDelete,
+		}
+		db := tx.Model(&eggModel.Query{}).Create(q)
+		if err = db.Error; err != nil {
+			log.Error("eggSrv.UpdateEgg create egg query error(%v)", err)
+			return
+		}
+	}
+	tx.Commit()
+	obj := map[string]interface{}{
+		"egg":   e,
+		"plat":  p,
+		"words": w,
+	}
+	if err = Log.AddLog(eggModel.Business, e.Person, e.UID, int64(e.ID), _ActionUpdate, obj); err != nil {
+		log.Error("eggSrv.AddEgg AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//AddEgg add egg
+func (s *Service) AddEgg(e *eggModel.Egg, p []eggModel.Plat, w []string) (err error) {
+	tx := s.dao.DB.Begin()
+	db := tx.Model(&eggModel.Egg{}).Create(e)
+	if err = db.Error; err != nil {
+		log.Error("eggSrv.AddEgg create egg error(%v)", err)
+		return
+	}
+	for _, v := range p {
+		v.EggID = e.ID
+		v.Deleted = eggModel.NotDelete
+		db := tx.Model(&eggModel.Plat{}).Create(v)
+		if err = db.Error; err != nil {
+			log.Error("eggSrv.AddEgg create egg plat error(%v)", err)
+			return
+		}
+	}
+	for _, v := range w {
+		q := eggModel.Query{
+			Word:    v,
+			EggID:   e.ID,
+			STime:   e.Stime,
+			ETime:   e.Etime,
+			Deleted: eggModel.NotDelete,
+		}
+		db := tx.Model(&eggModel.Query{}).Create(q)
+		if err = db.Error; err != nil {
+			log.Error("eggSrv.AddEgg create egg query error(%v)", err)
+			return
+		}
+	}
+	tx.Commit()
+	obj := map[string]interface{}{
+		"egg":   e,
+		"plat":  p,
+		"words": w,
+	}
+	if err = Log.AddLog(eggModel.Business, e.Person, e.UID, int64(e.ID), _ActionAdd, obj); err != nil {
+		log.Error("eggSrv.AddEgg AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//IsWdExist the word will add is exist
+func (s *Service) IsWdExist(words []string, sTime, eTime libTime.Time, eggID uint) (exist bool, w string, err error) {
+	var (
+		c int
+	)
+	for _, v := range words {
+		query := s.dao.DB.Model(&eggModel.Query{}).
+			Where("deleted=?", eggModel.NotDelete).
+			Where("word = ?", v).
+			Where("s_time < ?", eTime).
+			Where("e_time > ?", sTime)
+		if eggID != 0 {
+			query = query.Where("egg_id != ?", eggID)
+		}
+		if err = query.Count(&c).Error; err != nil {
+			log.Error("eggSrv.IsWdExist Query error(%v)", err)
+			return
+		}
+		if c > 0 {
+			return true, v, nil
+		}
+	}
+	return false, "", nil
+}
+
+func (s *Service) qWord(word string) (ids []uint, err error) {
+	q := []eggModel.Query{}
+	if err = s.dao.DB.Model(&eggModel.Query{}).Where("deleted=?", eggModel.NotDelete).
+		Where("word like ?", "%"+word+"%").Find(&q).Error; err != nil {
+		log.Error("eggSrv.IndexEgg Query error(%v)", err)
+		return
+	}
+	for _, v := range q {
+		ids = append(ids, v.EggID)
+	}
+	return
+}
+
+//IndexEgg egg list
+func (s *Service) IndexEgg(param *eggModel.IndexParam) (values *eggModel.IndexPager, err error) {
+	values = &eggModel.IndexPager{
+		Page: common.Page{
+			Num:  param.Pn,
+			Size: param.Ps,
+		},
+	}
+	w := map[string]interface{}{
+		"delete": eggModel.NotDelete,
+	}
+	if param.ID != "" {
+		w["id"] = param.ID
+	}
+	query := s.dao.DB.Model(&eggModel.Index{}).Where(w)
+	if param.Stime != "" {
+		query = query.Where("stime >= ?", param.Stime)
+	}
+	if param.Etime != "" {
+		query = query.Where("etime <= ?", param.Etime)
+	}
+	if param.Person != "" {
+		query = query.Where("person like ?", "%"+param.Person+"%")
+	}
+	if param.Word != "" {
+		var ids = []uint{}
+		if ids, err = s.qWord(param.Word); err != nil {
+			return
+		}
+		if len(ids) != 0 {
+			query = query.Where("id in (?)", ids)
+		} else {
+			query = query.Where("id in (?)", 0)
+		}
+	}
+	if err = query.Order("`id` DESC").Offset((param.Pn - 1) * param.Ps).Limit(param.Ps).Find(&values.Item).Error; err != nil {
+		log.Error("eggSrv.IndexEgg Index list error(%v)", err)
+		return
+	}
+	if err = query.Count(&values.Page.Total).Error; err != nil {
+		log.Error("eggSrv.IndexEgg Index count error(%v)", err)
+		return
+	}
+	for k, v := range values.Item {
+		q := []eggModel.Query{}
+		p := []eggModel.Plat{}
+		//select egg query words
+		w := map[string]interface{}{
+			"egg_id":  v.ID,
+			"deleted": eggModel.NotDelete,
+		}
+		if err = s.dao.DB.Model(&eggModel.Query{}).Where(w).Find(&q).Error; err != nil {
+			log.Error("eggSrv.IndexEgg Query error(%v)", err)
+			return
+		}
+		for _, qV := range q {
+			if values.Item[k].Words == "" {
+				values.Item[k].Words = qV.Word
+			} else {
+				values.Item[k].Words = values.Item[k].Words + "," + qV.Word
+			}
+		}
+		//select egg plat
+		w = map[string]interface{}{
+			"egg_id":  v.ID,
+			"deleted": eggModel.NotDelete,
+		}
+		if err = s.dao.DB.Model(&eggModel.Plat{}).Where(w).Find(&p).Error; err != nil {
+			log.Error("eggSrv.IndexEgg Plat error(%v)", err)
+			return
+		}
+		values.Item[k].Plat = p
+	}
+	return
+}
+
+//SearchEgg search egg list
+func (s *Service) SearchEgg() (values []eggModel.SearchEgg, err error) {
+	param := eggModel.IndexParam{}
+	w := map[string]interface{}{
+		"delete":  eggModel.NotDelete,
+		"publish": eggModel.Publish,
+	}
+	cTime := time.Now().Unix()
+	cTime = cTime + 10*60
+	tm := time.Unix(cTime, 0)
+	param.Stime = tm.Format("2006-01-02 15:04:05")
+	param.Etime = param.Stime
+	query := s.dao.DB.Model(&eggModel.SearchEgg{}).Where(w)
+	query = query.Where("stime <= ?", param.Stime).Where("etime >= ?", param.Etime)
+	if err = query.Order("`id` DESC").Find(&values).Error; err != nil {
+		log.Error("eggSrv.SearchEgg Index list error(%v)", err)
+		return
+	}
+	for k, v := range values {
+		q := []eggModel.Query{}
+		p := []eggModel.Plat{}
+		Words := []string{}
+		//select egg query words
+		w := map[string]interface{}{
+			"egg_id":  v.ID,
+			"deleted": eggModel.NotDelete,
+		}
+		if err = s.dao.DB.Model(&eggModel.Query{}).Where(w).Find(&q).Error; err != nil {
+			log.Error("eggSrv.IndexEgg Query error(%v)", err)
+			return
+		}
+		for _, v := range q {
+			Words = append(Words, v.Word)
+		}
+		values[k].Words = Words
+		//select egg plat
+		w = map[string]interface{}{
+			"egg_id":  v.ID,
+			"deleted": eggModel.NotDelete,
+		}
+		if err = s.dao.DB.Model(&eggModel.Plat{}).Where(w).Find(&p).Error; err != nil {
+			log.Error("eggSrv.IndexEgg Plat error(%v)", err)
+			return
+		}
+		values[k].Plat = make(map[uint8]eggModel.Plat)
+		for _, v := range p {
+			values[k].Plat[v.Plat] = v
+		}
+	}
+	return
+}
+
+//SearchEggWeb search egg list
+func (s *Service) SearchEggWeb() (values []eggModel.SearchEggWeb, err error) {
+	param := eggModel.IndexParam{}
+	w := map[string]interface{}{
+		"delete":  eggModel.NotDelete,
+		"publish": eggModel.Publish,
+	}
+	cTime := time.Now().Unix()
+	cTime = cTime + 10*60
+	tm := time.Unix(cTime, 0)
+	param.Stime = tm.Format("2006-01-02 15:04:05")
+	param.Etime = param.Stime
+	query := s.dao.DB.Model(&eggModel.SearchEgg{}).Where(w)
+	query = query.Where("stime <= ?", param.Stime).Where("etime >= ?", param.Etime)
+	if err = query.Order("`id` DESC").Find(&values).Error; err != nil {
+		log.Error("eggSrv.SearchEgg Index list error(%v)", err)
+		return
+	}
+	for k, v := range values {
+		q := []eggModel.Query{}
+		p := []eggModel.Plat{}
+		Words := []string{}
+		//select egg query words
+		w := map[string]interface{}{
+			"egg_id":  v.ID,
+			"deleted": eggModel.NotDelete,
+		}
+		if err = s.dao.DB.Model(&eggModel.Query{}).Where(w).Find(&q).Error; err != nil {
+			log.Error("eggSrv.IndexEgg Query error(%v)", err)
+			return
+		}
+		for _, v := range q {
+			Words = append(Words, v.Word)
+		}
+		values[k].Words = Words
+		//select egg plat
+		w = map[string]interface{}{
+			"egg_id":  v.ID,
+			"deleted": eggModel.NotDelete,
+		}
+		if err = s.dao.DB.Model(&eggModel.Plat{}).Where(w).Find(&p).Error; err != nil {
+			log.Error("eggSrv.IndexEgg Plat error(%v)", err)
+			return
+		}
+		values[k].Plat = make(map[uint8][]eggModel.Plat)
+		for _, v := range p {
+			values[k].Plat[v.Plat] = append(values[k].Plat[v.Plat], v)
+		}
+	}
+	return
+}

app/admin/main/feed/service/pgc/BUILD

@@ -0,0 +1,35 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["pgc.go"],
+    importpath = "go-common/app/admin/main/feed/service/pgc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/feed/conf:go_default_library",
+        "//app/admin/main/feed/dao/pgc:go_default_library",
+        "//app/service/openplatform/pgc-season/api/grpc/episode/v1:go_default_library",
+        "//app/service/openplatform/pgc-season/api/grpc/season/v1:go_default_library",
+        "//library/log: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/feed/service/pgc/pgc.go

@@ -0,0 +1,48 @@
+package pgc
+
+import (
+	"context"
+
+	"go-common/app/admin/main/feed/conf"
+	pgcdao "go-common/app/admin/main/feed/dao/pgc"
+	epgrpc "go-common/app/service/openplatform/pgc-season/api/grpc/episode/v1"
+	seasongrpc "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
+	"go-common/library/log"
+)
+
+// Service is egg service
+type Service struct {
+	pgc *pgcdao.Dao
+}
+
+// New new a egg service
+func New(c *conf.Config) (s *Service) {
+	var (
+		b   *pgcdao.Dao
+		err error
+	)
+	if b, err = pgcdao.New(c); err != nil {
+		log.Error("pgcdao.New error(%v)", err)
+		return
+	}
+	s = &Service{
+		pgc: b,
+	}
+	return
+}
+
+//GetSeason get season from pgc
+func (s *Service) GetSeason(c context.Context, seasonIDs []int32) (seasonCards map[int32]*seasongrpc.CardInfoProto, err error) {
+	if seasonCards, err = s.pgc.CardsInfoReply(c, seasonIDs); err != nil {
+		log.Error("%+v", err)
+	}
+	return
+}
+
+//GetEp get ep from pgc
+func (s *Service) GetEp(c context.Context, epIds []int32) (res map[int32]*epgrpc.EpisodeCardsProto, err error) {
+	if res, err = s.pgc.CardsEpInfoReply(c, epIds); err != nil {
+		log.Error("%+v", err)
+	}
+	return
+}

app/admin/main/feed/service/popular/BUILD

@@ -0,0 +1,39 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "event_topic.go",
+        "service.go",
+        "stars.go",
+    ],
+    importpath = "go-common/app/admin/main/feed/service/popular",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/feed/conf:go_default_library",
+        "//app/admin/main/feed/dao/show:go_default_library",
+        "//app/admin/main/feed/model/common:go_default_library",
+        "//app/admin/main/feed/model/show:go_default_library",
+        "//app/admin/main/feed/util:go_default_library",
+        "//library/log:go_default_library",
+        "//vendor/github.com/jinzhu/gorm: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/feed/service/popular/event_topic.go

@@ -0,0 +1,88 @@
+package popular
+
+import (
+	"context"
+	"go-common/app/admin/main/feed/model/common"
+	"go-common/app/admin/main/feed/model/show"
+	"go-common/app/admin/main/feed/util"
+	"go-common/library/log"
+)
+
+const (
+	//ActionAddCEventTopic log action
+	ActionAddCEventTopic = "ActAddEventTopic"
+	//ActionUpCEventTopic log action
+	ActionUpCEventTopic = "ActUpEventTopic"
+	//ActionDelCEventTopic log action
+	ActionDelCEventTopic = "ActDelEventTopic"
+)
+
+//EventTopicList channel EventTopic list
+func (s *Service) EventTopicList(lp *show.EventTopicLP) (pager *show.EventTopicPager, err error) {
+	pager = &show.EventTopicPager{
+		Page: common.Page{
+			Num:  lp.Pn,
+			Size: lp.Ps,
+		},
+	}
+	w := map[string]interface{}{
+		"deleted": common.NotDeleted,
+	}
+	query := s.showDao.DB.Model(&show.EventTopic{})
+	if lp.ID > 0 {
+		w["id"] = lp.ID
+	}
+	if lp.Person != "" {
+		query = query.Where("person like ?", "%"+lp.Person+"%")
+	}
+	if lp.Title != "" {
+		query = query.Where("title like ?", "%"+lp.Title+"%")
+	}
+	if err = query.Where(w).Count(&pager.Page.Total).Error; err != nil {
+		log.Error("popularSvc.EventTopicList count error(%v)", err)
+		return
+	}
+	EventTopics := make([]*show.EventTopic, 0)
+	if err = query.Where(w).Order("`id` DESC").Offset((lp.Pn - 1) * lp.Ps).Limit(lp.Ps).Find(&EventTopics).Error; err != nil {
+		log.Error("popularSvc.EventTopicList Find error(%v)", err)
+		return
+	}
+	pager.Item = EventTopics
+	return
+}
+
+//AddEventTopic add channel EventTopic
+func (s *Service) AddEventTopic(c context.Context, param *show.EventTopicAP, name string, uid int64) (err error) {
+	if err = s.showDao.EventTopicAdd(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogEventTopic, name, uid, 0, ActionAddCEventTopic, param); err != nil {
+		log.Error("popularSvc.AddEventTopic AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//UpdateEventTopic update channel EventTopic
+func (s *Service) UpdateEventTopic(c context.Context, param *show.EventTopicUP, name string, uid int64) (err error) {
+	if err = s.showDao.EventTopicUpdate(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogEventTopic, name, uid, 0, ActionUpCEventTopic, param); err != nil {
+		log.Error("popularSvc.UpdateEventTopic AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//DeleteEventTopic delete channel EventTopic
+func (s *Service) DeleteEventTopic(id int64, name string, uid int64) (err error) {
+	if err = s.showDao.EventTopicDelete(id); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogEventTopic, name, uid, id, ActionDelCEventTopic, id); err != nil {
+		log.Error("popularSvc.DeleteEventTopic AddLog error(%v)", err)
+		return
+	}
+	return
+}

app/admin/main/feed/service/popular/service.go

@@ -0,0 +1,19 @@
+package popular
+
+import (
+	"go-common/app/admin/main/feed/conf"
+	showdao "go-common/app/admin/main/feed/dao/show"
+)
+
+// Service is search service
+type Service struct {
+	showDao *showdao.Dao
+}
+
+// New new a search service
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		showDao: showdao.New(c),
+	}
+	return
+}

app/admin/main/feed/service/popular/stars.go

@@ -0,0 +1,218 @@
+package popular
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/admin/main/feed/model/common"
+	"go-common/app/admin/main/feed/model/show"
+	"go-common/app/admin/main/feed/util"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+)
+
+const (
+	//ActionAddCPopular .
+	ActionAddCPopular = "ActAddPopularStars"
+	//ActionUpCPopular .
+	ActionUpCPopular = "ActUpPopularStars"
+	//ActionDelCPopular .
+	ActionDelCPopular = "ActDelPopularStars"
+	//ActionRejCPopular .
+	ActionRejCPopular = "ActRejPopularStars"
+	//_CardTypeUpRcmdNew 热门新星卡片
+	_CardTypeUpRcmdNew = "up_rcmd_new"
+	//ActionAIAddCPopular .
+	ActionAIAddCPopular = "ActAIAddPopularStars"
+	//_CardSourceOperate popular stars build by operate
+	_CardSourceOperate = 0
+	//_CardSourceAI popular stars build by ai
+	_CardSourceAI = 1
+)
+
+//PopularStarsList channel Popular list
+func (s *Service) PopularStarsList(lp *show.PopularStarsLP) (pager *show.PopularStarsPager, err error) {
+	pager = &show.PopularStarsPager{
+		Page: common.Page{
+			Num:  lp.Pn,
+			Size: lp.Ps,
+		},
+	}
+	w := map[string]interface{}{
+		"deleted": common.NotDeleted,
+		"type":    _CardTypeUpRcmdNew,
+	}
+	query := s.showDao.DB.Model(&show.PopularStars{})
+	if lp.ID > 0 {
+		w["id"] = lp.ID
+	}
+	if lp.Status > 0 {
+		w["status"] = lp.Status
+	}
+	if lp.Source >= 0 {
+		if lp.Source == 0 {
+			query = query.Where(map[string]interface{}{"source": _CardSourceOperate})
+		} else {
+			w["source"] = lp.Source
+		}
+	}
+	if lp.Person != "" {
+		query = query.Where("person like ?", "%"+lp.Person+"%")
+	}
+	if lp.LongTitle != "" {
+		query = query.Where("long_title like ?", "%"+lp.LongTitle+"%")
+	}
+	if err = query.Where(w).Count(&pager.Page.Total).Error; err != nil {
+		log.Error("popularSvc.PopularStarsList Index count error(%v)", err)
+		return
+	}
+	Populars := make([]*show.PopularStars, 0)
+	if err = query.Where(w).Order("`id` DESC").Offset((lp.Pn - 1) * lp.Ps).Limit(lp.Ps).Find(&Populars).Error; err != nil {
+		log.Error("popularSvc.PopularStarsList First error(%v)", err)
+		return
+	}
+	pager.Item = Populars
+	return
+}
+
+//AddPopularStars add popular stars
+func (s *Service) AddPopularStars(c context.Context, param *show.PopularStarsAP, name string, uid int64) (err error) {
+	var (
+		popStars *show.PopularStars
+	)
+	if popStars, err = s.ValidMid(param.Value); err != nil {
+		fmt.Println("error")
+		return
+	}
+	if popStars.ID != 0 {
+		err = fmt.Errorf("up主ID 已存在")
+		return
+	}
+	param.Type = _CardTypeUpRcmdNew
+	param.Source = _CardSourceOperate
+	param.Status = common.Pass
+	if err = s.showDao.PopularStarsAdd(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogPopularStars, name, uid, 0, ActionAddCPopular, param); err != nil {
+		log.Error("popularSvc.AddPopularStars AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//UpdatePopularStars update channel Popular
+func (s *Service) UpdatePopularStars(c context.Context, param *show.PopularStarsUP, name string, uid int64) (err error) {
+	var (
+		popStars *show.PopularStars
+	)
+	if popStars, err = s.ValidMid(param.Value); err != nil {
+		return
+	}
+	if popStars.ID != 0 && popStars.ID != param.ID {
+		err = fmt.Errorf("up主ID 已存在")
+		return
+	}
+	param.Type = _CardTypeUpRcmdNew
+	param.Status = common.Pass
+	if err = s.showDao.PopularStarsUpdate(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogPopularStars, name, uid, 0, ActionUpCPopular, param); err != nil {
+		log.Error("popularSvc.UpdatePopularStars AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//DeletePopularStars delete channel Popular
+func (s *Service) DeletePopularStars(id int64, name string, uid int64) (err error) {
+	if err = s.showDao.PopularStarsDelete(id, _CardTypeUpRcmdNew); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogPopularStars, name, uid, id, ActionDelCPopular, id); err != nil {
+		log.Error("popularSvc.DeletePopularStars AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//RejectPopularStars reject channel Popular
+func (s *Service) RejectPopularStars(id int64, name string, uid int64) (err error) {
+	if err = s.showDao.PopularStarsReject(id, _CardTypeUpRcmdNew); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogPopularStars, name, uid, id, ActionRejCPopular, id); err != nil {
+		log.Error("popularSvc.DeletePopularStars AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//ValidMid mid must unique
+func (s *Service) ValidMid(mid string) (popStars *show.PopularStars, err error) {
+	w := map[string]interface{}{
+		"value":   mid,
+		"deleted": common.NotDeleted,
+		"type":    _CardTypeUpRcmdNew,
+	}
+	popStars = &show.PopularStars{}
+	if err = s.showDao.DB.Model(&show.PopularStars{}).Where(w).Find(&popStars).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			err = nil
+			return
+		}
+		log.Error("popularSvc.ValidMid Find error(%v)", err)
+		return
+	}
+	return
+}
+
+//AIAddPopularStars add popular stars
+func (s *Service) AIAddPopularStars(c context.Context, values []*show.PopularStarsAP) (err error) {
+	if err = util.AddLogs(common.LogPopularStars, "AI", 0, 0, ActionAIAddCPopular, values); err != nil {
+		log.Error("popularSvc.AIAddPopularStars AddLog error(%v)", err)
+		return
+	}
+	for _, v := range values {
+		var popStars *show.PopularStars
+		if popStars, err = s.ValidMid(v.Value); err != nil {
+			log.Error("popularSvc.AIAddPopularStars ValidMid value(%v) error(%v)", v, err)
+			continue
+		}
+		if popStars.ID != 0 {
+			//运营创建的优先级最高
+			if popStars.Source == _CardSourceOperate {
+				continue
+			}
+			//已通过的优先级较高
+			if popStars.Status == common.Pass {
+				continue
+			}
+			tmp := &show.PopularStarsUP{
+				ID:        popStars.ID,
+				Content:   v.Content,
+				LongTitle: v.LongTitle,
+			}
+			if err = s.showDao.PopularStarsUpdate(tmp); err != nil {
+				log.Error("popularSvc.AIAddPopularStars PopularStarsUpdate value(%v) error(%v)", tmp, err)
+				continue
+			}
+		} else {
+			tmp := &show.PopularStarsAP{
+				Type:      _CardTypeUpRcmdNew,
+				Source:    _CardSourceAI,
+				Status:    common.Verify,
+				Value:     v.Value,
+				Content:   v.Content,
+				LongTitle: v.LongTitle,
+			}
+			if err = s.showDao.PopularStarsAdd(tmp); err != nil {
+				log.Error("popularSvc.AIAddPopularStars PopularStarsAdd value(%v) error(%v)", tmp, err)
+				continue
+			}
+		}
+	}
+	return
+}

app/admin/main/feed/service/search/BUILD

@@ -0,0 +1,60 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "search.go",
+        "search_web.go",
+    ],
+    importpath = "go-common/app/admin/main/feed/service/search",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/main/feed/conf:go_default_library",
+        "//app/admin/main/feed/dao/search:go_default_library",
+        "//app/admin/main/feed/dao/show:go_default_library",
+        "//app/admin/main/feed/model/common:go_default_library",
+        "//app/admin/main/feed/model/search:go_default_library",
+        "//app/admin/main/feed/model/show:go_default_library",
+        "//app/admin/main/feed/util:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+        "//vendor/github.com/robfig/cron: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["search_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/admin/main/feed/conf:go_default_library",
+        "//app/admin/main/feed/model/search:go_default_library",
+        "//library/log:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/admin/main/feed/service/search/search_test.go

@@ -0,0 +1,543 @@
+package search
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"go-common/app/admin/main/feed/conf"
+	searchModel "go-common/app/admin/main/feed/model/search"
+	"go-common/library/log"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	s *Service
+	c = context.Background()
+)
+
+func init() {
+	var (
+		err error
+	)
+	dir, _ := filepath.Abs("../../cmd/feed-admin-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	if s = New(conf.Conf); err != nil {
+		log.Error("bgmdao.New error(%v)", err)
+		return
+	}
+}
+
+func TestIsTodayAutoPubHot(t *testing.T) {
+	convey.Convey("isTodayAutoPubHot", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			err error
+			res bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err = s.isTodayAutoPubHot(c)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestIsTodayAutoPubDark(t *testing.T) {
+	convey.Convey("isTodayAutoPubDark", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err = s.isTodayAutoPubDark(c)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestParseTime(t *testing.T) {
+	convey.Convey("parseTime", t, func(ctx convey.C) {
+		var (
+			err error
+			res time.Time
+		)
+		timeTwelve := time.Now().Format("2006-01-02 ") + "12:00:00"
+		layout := "2006-01-02 15:04:05"
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err = s.parseTime(timeTwelve, layout)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestHotwordFromDB(t *testing.T) {
+	convey.Convey("HotwordFromDB", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Intervene
+		)
+
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, _, err = s.HotwordFromDB("2018-09-05")
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestDarkwordFromDB(t *testing.T) {
+	convey.Convey("HotwordFromDB", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Dark
+		)
+
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, _, err = s.DarkwordFromDB(time.Now().Format("2006-01-02"))
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestOpenHotList(t *testing.T) {
+	convey.Convey("HotwordFromDB", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Intervene
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//c = context.Background()
+			//res, err = s.OpenHotList(c)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestHotList(t *testing.T) {
+	convey.Convey("HotList", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Intervene
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//res, err = s.HotList(c)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestDarkList(t *testing.T) {
+	convey.Convey("DarkList", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Intervene
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//res, err = s.DarkList(c)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestBlackList(t *testing.T) {
+	convey.Convey("BlackList", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Black
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err = s.BlackList()
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestDelBlack(t *testing.T) {
+	convey.Convey("DelBlack", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Black
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//res, err = s.DelBlack()
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestAddBlack(t *testing.T) {
+	convey.Convey("AddBlack", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Black
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//err = s.AddBlack()
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestCheckBlack(t *testing.T) {
+	convey.Convey("checkBlack", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err = s.checkBlack("test")
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestCheckInter(t *testing.T) {
+	convey.Convey("checkInter", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err = s.checkInter("test", 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestCheckTimeConflict(t *testing.T) {
+	convey.Convey("checkTimeConflict", t, func(ctx convey.C) {
+		var (
+			err   error
+			res   bool
+			model = searchModel.InterveneAdd{
+				Rank:  10,
+				Stime: 1536134791,
+				Etime: 1536134791,
+			}
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, err = s.checkTimeConflict(model, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestAddInter(t *testing.T) {
+	convey.Convey("checkTimeConflict", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//res, err = s.AddInter(model, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestUpdateInter(t *testing.T) {
+	convey.Convey("UpdateInter", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//res, err = s.AddInter(model, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestUpdateSearch(t *testing.T) {
+	convey.Convey("UpdateSearch", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//res, err = s.AddInter(model, 0)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestDeleteHot(t *testing.T) {
+	convey.Convey("DeleteHot", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err = s.DeleteHot(c, 10, 2, "quguolin", 100)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestDeleteDark(t *testing.T) {
+	convey.Convey("DeleteDark", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err = s.DeleteDark(c, 10, "quguolin", 100)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestOpenAddDarkword(t *testing.T) {
+	convey.Convey("OpenAddDarkword", t, func(ctx convey.C) {
+		var (
+			err   error
+			res   bool
+			value searchModel.OpenDark
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err = s.OpenAddDarkword(c, value)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestOpenAddHotword(t *testing.T) {
+	convey.Convey("OpenAddHotword", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+			//value searchModel.OpenHot
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//err = s.OpenAddHotword(c, value)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestGetHotPub(t *testing.T) {
+	convey.Convey("GetHotPub", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+			//value searchModel.OpenHot
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//err = s.OpenAddHotword(c, value)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestGetDarkPub(t *testing.T) {
+	convey.Convey("GetDarkPub", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+			//value searchModel.OpenHot
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			//err = s.GetDarkPub(c, value)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestSetHotPub(t *testing.T) {
+	convey.Convey("SetHotPub", t, func(ctx convey.C) {
+		var (
+			err error
+			res bool
+			//value searchModel.OpenHot
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err = s.SetHotPub(c, "quguolin", 100)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestHotPubLog(t *testing.T) {
+	convey.Convey("HotPubLog", t, func(ctx convey.C) {
+		var (
+			err   error
+			res   bool
+			value []searchModel.Intervene
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			err = s.HotPubLog(value)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestGetHotPubLog(t *testing.T) {
+	convey.Convey("GetHotPubLog", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Intervene
+			pub bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, pub, err = s.GetHotPubLog("2018-09-03")
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				//ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res, pub)
+		})
+	})
+}
+
+func TestGetDarkPubLog(t *testing.T) {
+	convey.Convey("GetDarkPubLog", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Dark
+			pub bool
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			res, pub, err = s.GetDarkPubLog("2018-09-03")
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				//ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res, pub)
+		})
+	})
+}
+
+func TestSetDarkPub(t *testing.T) {
+	convey.Convey("SetDarkPub", t, func(ctx convey.C) {
+		var (
+			err error
+			res []searchModel.Intervene
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			s.SetDarkPub(c, "quguolin", 10)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				//ctx.So(res, convey.ShouldNotBeNil)
+			})
+			fmt.Println(res)
+		})
+	})
+}
+
+func TestDarkPubLog(t *testing.T) {
+	convey.Convey("DarkPubLog", t, func(ctx convey.C) {
+		var (
+			err  error
+			dark []searchModel.Dark
+		)
+		ctx.Convey("When everything goes positive", func(ctx convey.C) {
+			s.DarkPubLog(dark)
+			ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				//ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/admin/main/feed/service/search/search_web.go

@@ -0,0 +1,430 @@
+package search
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+
+	"go-common/app/admin/main/feed/model/common"
+	"go-common/app/admin/main/feed/model/show"
+	showModel "go-common/app/admin/main/feed/model/show"
+	"go-common/app/admin/main/feed/util"
+	"go-common/library/log"
+
+	"github.com/jinzhu/gorm"
+)
+
+const (
+	//_ActAddSearchWebCard log action
+	_ActAddSearchWebCard = "ActAddSearchWebCard"
+	//_ActUpSearchWebCard log action
+	_ActUpSearchWebCard = "ActUpSearchWebCard"
+	//_ActDelSearchWebCard log action
+	_ActDelSearchWebCard = "ActDelSearchWebCard"
+	//_ActAddSearchWeb log action
+	_ActAddSearchWeb = "ActAddSearchWeb"
+	//_ActUpSearchWeb log action
+	_ActUpSearchWeb = "ActUpSearchWeb"
+	//_ActDelSearchWeb log action
+	_ActDelSearchWeb = "ActDelSearchWeb"
+	//_ActOptSearchWeb log action
+	_ActOptSearchWeb = "ActOptSearchWeb"
+)
+
+var (
+	_emptyWebQuery = make([]*show.SearchWebQuery, 0)
+)
+
+//SearchWebCardList channel SearchWebCard list
+func (s *Service) SearchWebCardList(lp *show.SearchWebCardLP) (pager *show.SearchWebCardPager, err error) {
+	pager = &show.SearchWebCardPager{
+		Page: common.Page{
+			Num:  lp.Pn,
+			Size: lp.Ps,
+		},
+	}
+	w := map[string]interface{}{
+		"deleted": common.NotDeleted,
+	}
+	query := s.showDao.DB.Model(&show.SearchWebCard{})
+	if lp.ID > 0 {
+		w["id"] = lp.ID
+	}
+	if lp.Person != "" {
+		query = query.Where("person like ?", "%"+lp.Person+"%")
+	}
+	if lp.Title != "" {
+		query = query.Where("title like ?", "%"+lp.Title+"%")
+	}
+	if lp.STime != "" {
+		query = query.Where("ctime >= ?", lp.STime)
+	}
+	if lp.ETime != "" {
+		query = query.Where("ctime <= ?", lp.ETime)
+	}
+	if err = query.Where(w).Count(&pager.Page.Total).Error; err != nil {
+		log.Error("searchWebSvc.SearchWebCardList count error(%v)", err)
+		return
+	}
+	SearchWebCards := make([]*show.SearchWebCard, 0)
+	if err = query.Where(w).Order("`id` DESC").Offset((lp.Pn - 1) * lp.Ps).Limit(lp.Ps).Find(&SearchWebCards).Error; err != nil {
+		log.Error("searchWebSvc.SearchWebCardList Find error(%v)", err)
+		return
+	}
+	pager.Item = SearchWebCards
+	return
+}
+
+//AddSearchWebCard add channel SearchWebCard
+func (s *Service) AddSearchWebCard(c context.Context, param *show.SearchWebCardAP, name string, uid int64) (err error) {
+	if err = s.showDao.SearchWebCardAdd(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogSWEBCard, name, uid, 0, _ActAddSearchWebCard, param); err != nil {
+		log.Error("searchWebSvc.AddSearchWebCard AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//UpdateSearchWebCard update channel SearchWebCard
+func (s *Service) UpdateSearchWebCard(c context.Context, param *show.SearchWebCardUP, name string, uid int64) (err error) {
+	if err = s.showDao.SearchWebCardUpdate(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogSWEBCard, name, uid, 0, _ActUpSearchWebCard, param); err != nil {
+		log.Error("searchWebSvc.UpdateSearchWebCard AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//DeleteSearchWebCard delete channel SearchWebCard
+func (s *Service) DeleteSearchWebCard(id int64, name string, uid int64) (err error) {
+	if err = s.showDao.SearchWebCardDelete(id); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogSWEBCard, name, uid, id, _ActDelSearchWebCard, id); err != nil {
+		log.Error("searchWebSvc.DeleteSearchWebCard AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//SearchWebList SearchWeb list
+func (s *Service) SearchWebList(lp *show.SearchWebLP) (pager *show.SearchWebPager, err error) {
+	pager = &show.SearchWebPager{
+		Page: common.Page{
+			Num:  lp.Pn,
+			Size: lp.Ps,
+		},
+	}
+	w := map[string]interface{}{
+		"deleted": common.NotDeleted,
+	}
+	query := s.showDao.DB.Model(&show.SearchWeb{})
+	if lp.ID > 0 {
+		w["id"] = lp.ID
+	}
+	if lp.Person != "" {
+		query = query.Where("person like ?", "%"+lp.Person+"%")
+	}
+	if lp.STime != "" {
+		query = query.Where("stime >= ?", lp.STime)
+	}
+	if lp.ETime != "" {
+		query = query.Where("etime <= ?", lp.ETime)
+	}
+	cTimeStr := util.CTimeStr()
+	if lp.Check != 0 {
+		if lp.Check == common.Pass {
+			//已通过 未生效
+			query = query.Where("`check` = ?", common.Pass)
+			query = query.Where("stime > ?", cTimeStr)
+		} else if lp.Check == common.Valid {
+			//已通过 已生效
+			query = query.Where("`check` = ?", common.Pass)
+			query = query.Where("stime <= ?", cTimeStr).Where("etime >= ?", cTimeStr)
+		} else if lp.Check == common.InValid {
+			//已通过 已失效
+			query = query.Where("(`check` = ? AND etime <= ?) OR (`check` = ?)", common.Pass, cTimeStr, common.InValid)
+		} else {
+			query = query.Where("`check` = ? ", lp.Check)
+		}
+	}
+	if err = query.Where(w).Count(&pager.Page.Total).Error; err != nil {
+		log.Error("searchSvc.SearchWebList count error(%v)", err)
+		return
+	}
+	SearchWebs := make([]*show.SearchWeb, 0)
+	if err = query.Where(w).Order("`id` DESC").Offset((lp.Pn - 1) * lp.Ps).Limit(lp.Ps).Find(&SearchWebs).Error; err != nil {
+		log.Error("searchSvc.SearchWebList Find error(%v)", err)
+		return
+	}
+	if len(SearchWebs) > 0 {
+		var (
+			ids      []int64
+			queryMap map[int64][]*show.SearchWebQuery
+		)
+		for _, v := range SearchWebs {
+			if v.Check == common.Pass {
+				c := time.Now().Unix()
+				if (c >= v.Stime.Time().Unix()) && (c <= v.Etime.Time().Unix()) {
+					v.Check = common.Valid
+				} else if c > v.Etime.Time().Unix() && v.Check != common.InValid {
+					v.Check = common.InValid
+					v.Status = common.StatusDownline
+				}
+			}
+			webCard := &show.SearchWebCard{}
+			cardWhere := map[string]interface{}{
+				"deleted": common.NotDeleted,
+				"id":      v.CardValue,
+			}
+			if err = s.showDao.DB.Model(&show.SearchWebCard{}).Where(cardWhere).First(webCard).Error; err != nil {
+				if err == gorm.ErrRecordNotFound {
+					err = nil
+				} else {
+					log.Error("searchSvc.SearchWebCard Find error(%v)", err)
+					return
+				}
+			}
+			v.Card = webCard
+			ids = append(ids, v.ID)
+		}
+		where := map[string]interface{}{
+			"deleted": common.NotDeleted,
+		}
+		SearchWebQuery := make([]*show.SearchWebQuery, 0)
+		if err = s.showDao.DB.Model(&show.SearchWebQuery{}).Where(where).Where("sid in (?)", ids).Find(&SearchWebQuery).Error; err != nil {
+			log.Error("searchSvc.SearchWebList Find error(%v)", err)
+			return
+		}
+		queryMap = make(map[int64][]*show.SearchWebQuery, len(SearchWebQuery))
+		for _, v := range SearchWebQuery {
+			queryMap[v.SID] = append(queryMap[v.SID], v)
+		}
+		for _, v := range SearchWebs {
+			if value, ok := queryMap[v.ID]; ok {
+				v.Query = value
+			} else {
+				v.Query = _emptyWebQuery
+			}
+		}
+	}
+	pager.Item = SearchWebs
+	return
+}
+
+//OpenSearchWebList SearchWeb list
+func (s *Service) OpenSearchWebList() (SearchWebs []*show.SearchWeb, err error) {
+	cTimeStr := util.CTimeStr()
+	SearchWebs = make([]*show.SearchWeb, 0)
+	w := map[string]interface{}{
+		"deleted": common.NotDeleted,
+		"check":   common.Pass,
+	}
+	query := s.showDao.DB.Model(&show.SearchWeb{})
+	//已通过 已生效
+	query = query.Where("stime <= ?", cTimeStr).Where("etime >= ?", cTimeStr)
+	if err = query.Where(w).Order("`id` DESC").Find(&SearchWebs).Error; err != nil {
+		log.Error("searchSvc.OpenSearchWebList Find error(%v)", err)
+		return
+	}
+	if len(SearchWebs) > 0 {
+		var (
+			ids      []int64
+			queryMap map[int64][]*show.SearchWebQuery
+		)
+		for _, v := range SearchWebs {
+			webCard := &show.SearchWebCard{}
+			cardWhere := map[string]interface{}{
+				"deleted": common.NotDeleted,
+				"id":      v.CardValue,
+			}
+			if err = s.showDao.DB.Model(&show.SearchWebCard{}).Where(cardWhere).First(webCard).Error; err != nil {
+				if err == gorm.ErrRecordNotFound {
+					err = nil
+					webCard = nil
+				} else {
+					log.Error("searchSvc.OpenSearchWebList Find error(%v)", err)
+				}
+			}
+			if webCard != nil {
+				v.Card = webCard
+			} else {
+				v.Card = struct{}{}
+			}
+			ids = append(ids, v.ID)
+		}
+		where := map[string]interface{}{
+			"deleted": common.NotDeleted,
+		}
+		SearchWebQuery := make([]*show.SearchWebQuery, 0)
+		if err = s.showDao.DB.Model(&show.SearchWebQuery{}).Where(where).Where("sid in (?)", ids).Find(&SearchWebQuery).Error; err != nil {
+			log.Error("searchSvc.OpenSearchWebList Find error(%v)", err)
+			return
+		}
+		queryMap = make(map[int64][]*show.SearchWebQuery, len(SearchWebQuery))
+		for _, v := range SearchWebQuery {
+			queryMap[v.SID] = append(queryMap[v.SID], v)
+		}
+		for _, v := range SearchWebs {
+			if value, ok := queryMap[v.ID]; ok {
+				v.Query = value
+			} else {
+				v.Query = _emptyWebQuery
+			}
+		}
+	}
+	return
+}
+
+//Validate validate search web card
+func (s *Service) Validate(p *show.SWTimeValid) (err error) {
+	var (
+		querys  []*show.SearchWebQuery
+		webCard *showModel.SearchWebCard
+		id      int64
+	)
+	if id, err = strconv.ParseInt(p.CardValue, 10, 64); err != nil {
+		return
+	}
+	if webCard, err = s.showDao.SWBFindByID(id); err != nil {
+		return err
+	}
+	if webCard == nil {
+		return fmt.Errorf("无效web卡片ID(%d)", id)
+	}
+	if err = json.Unmarshal([]byte(p.Query), &querys); err != nil {
+		log.Error("searchSvc.Validate json.Unmarshal(%v) error(%v)", p, err)
+		return
+	}
+	if len(querys) == 0 {
+		err = fmt.Errorf("query不能为空")
+		return
+	}
+	for _, v := range querys {
+		count := 0
+		p.Query = v.Value
+		if count, err = s.showDao.SWTimeValid(p); err != nil {
+			return
+		}
+		if count > 0 {
+			err = fmt.Errorf("相同query(%s)该位置已有运营卡片", v.Value)
+		}
+	}
+	return
+}
+
+//AddSearchWeb add SearchWeb
+func (s *Service) AddSearchWeb(c context.Context, param *show.SearchWebAP, name string, uid int64) (err error) {
+	p := &show.SWTimeValid{
+		Priority:  param.Priority,
+		STime:     param.Stime,
+		ETime:     param.Etime,
+		Query:     param.Query,
+		CardValue: param.CardValue,
+	}
+	if err = s.Validate(p); err != nil {
+		return
+	}
+	if err = s.showDao.SearchWebAdd(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogSWEB, name, uid, 0, _ActAddSearchWeb, param); err != nil {
+		log.Error("searchSvc.AddSearchWeb AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//UpdateSearchWeb update SearchWeb
+func (s *Service) UpdateSearchWeb(c context.Context, param *show.SearchWebUP, name string, uid int64) (err error) {
+	var (
+		swValue *show.SearchWeb
+	)
+	p := &show.SWTimeValid{
+		ID:        param.ID,
+		Priority:  param.Priority,
+		STime:     param.Stime,
+		ETime:     param.Etime,
+		Query:     param.Query,
+		CardValue: param.CardValue,
+	}
+	if err = s.Validate(p); err != nil {
+		return
+	}
+	if swValue, err = s.showDao.SWFindByID(param.ID); err != nil {
+		log.Error("searchSvc.UpdateSearchWeb AddLog error(%v)", err)
+		return
+	}
+	//待审核&已通过&已生效-》编辑-》状态不变；其它-》编辑-》审待核
+	cTime := time.Now().Unix()
+	if (swValue.Check == common.Verify) ||
+		(swValue.Check == common.Pass && swValue.Stime.Time().Unix() > cTime ||
+			(swValue.Check == common.Pass && (cTime > swValue.Stime.Time().Unix() && cTime <= swValue.Stime.Time().Unix()))) {
+		param.Check = swValue.Check
+		param.Status = swValue.Status
+	} else {
+		param.Check = common.Verify
+		param.Status = common.StatusDownline
+	}
+	if err = s.showDao.SearchWebUpdate(param); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogSWEB, name, uid, 0, _ActUpSearchWeb, param); err != nil {
+		log.Error("searchSvc.UpdateSearchWeb AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//DeleteSearchWeb delete SearchWeb
+func (s *Service) DeleteSearchWeb(id int64, name string, uid int64) (err error) {
+	if err = s.showDao.SearchWebDelete(id); err != nil {
+		return
+	}
+	if err = util.AddLogs(common.LogSWEB, name, uid, id, _ActDelSearchWeb, id); err != nil {
+		log.Error("searchSvc.DeleteSearchWeb AddLog error(%v)", err)
+		return
+	}
+	return
+}
+
+//OptionSearchWeb option SearchWeb
+func (s *Service) OptionSearchWeb(id int64, opt string, name string, uid int64) (err error) {
+	up := &show.SearchWebOption{}
+	if opt == common.OptionOnline {
+		up.Status = common.StatusOnline
+		up.Check = common.Pass
+	} else if opt == common.OptionHidden {
+		up.Status = common.StatusDownline
+		up.Check = common.InValid
+	} else if opt == common.OptionPass {
+		up.Status = common.StatusOnline
+		up.Check = common.Pass
+	} else if opt == common.OptionReject {
+		up.Status = common.StatusDownline
+		up.Check = common.Rejecte
+	} else {
+		err = fmt.Errorf("参数不合法")
+		return
+	}
+	up.ID = id
+	if err = s.showDao.SearchWebOption(up); err != nil {
+		return
+	}
+	logParam := map[string]interface{}{
+		"id":  id,
+		"opt": opt,
+		"up":  up,
+	}
+	if err = util.AddLogs(common.LogSWEB, name, uid, id, _ActOptSearchWeb, logParam); err != nil {
+		log.Error("searchSvc.OptionSearchWeb AddLog error(%v)", err)
+		return
+	}
+	return
+}