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

package search

import (
	"context"
	"fmt"
	"time"

	"go-common/app/admin/main/feed/conf"
	"go-common/app/admin/main/feed/dao/search"
	"go-common/app/admin/main/feed/dao/show"
	searchModel "go-common/app/admin/main/feed/model/search"
	Log "go-common/app/admin/main/feed/util"
	"go-common/library/cache/memcache"
	"go-common/library/log"
	bm "go-common/library/net/http/blademaster"

	"github.com/jinzhu/gorm"
	"github.com/robfig/cron"
)

var (
	ctx = context.TODO()
)

// Service is search service
type Service struct {
	dao      *search.Dao
	showDao  *show.Dao
	cronHot  *cron.Cron
	HotFre   string
	cronDark *cron.Cron
	DarkFre  string
}

const (
	_HotPubState        = "tianma_search_hot_state"
	_HotPubValue        = "tianma_search_hot_value"
	_HotPubSearchState  = "tianma_search_hot_search_state"
	_DarkPubState       = "tianma_search_dark_state"
	_DarkPubValue       = "tianma_search_dark_value"
	_DarkPubSearchState = "tianma_search_dark_search_state"
	_HotAutoPubState    = "tianma_search_auto_hot_state"
	_DarkAutoPubState   = "tianma_search_auto_dark_state"
	_HotShowUnpub       = 0
	_HotShowPub         = 1
	_HotShowUnUp        = 2
	_DarkShowUnpub      = 0
	_DarkShowPub        = 1
	_DarkShowUnUp       = 2
)

// New new a search service
func New(c *conf.Config) (s *Service) {
	s = &Service{
		dao:      search.New(c),
		showDao:  show.New(c),
		cronHot:  cron.New(),
		cronDark: cron.New(),
		HotFre:   c.Cfg.HotCroFre,
		DarkFre:  c.Cfg.DarkCroFre,
	}
	go s.CrontLoad()
	s.cronHot.Start()
	s.cronDark.Start()
	return
}

//CrontLoad search box history
func (s *Service) CrontLoad() (err error) {
	if err = s.cronHot.AddFunc(s.HotFre, s.LoadHot); err != nil {
		log.Error("searchSrv.CrontLoaHot AddFunc LoadHot error(%v)", err)
		panic(err)
	}
	if err = s.cronDark.AddFunc(s.DarkFre, s.LoadDark); err != nil {
		log.Error("searchSrv.CrontLoaHot AddFunc LoadDark error(%v)", err)
		panic(err)
	}
	return
}

//LoadHot crontab auto load hot word
func (s *Service) LoadHot() {
	var (
		err    error
		status bool
	)
	timeTwelve := time.Now().Format("2006-01-02 ") + "12:00:00"
	timeTwelveStr, _ := s.parseTime(timeTwelve, "2006-01-02 15:04:05")
	timeZero := time.Now().Format("2006-01-02 ") + "00:00:00"
	timeZeroStr, _ := s.parseTime(timeZero, "2006-01-02 15:04:05")
	log.Info("searchSrv.LoadHot Auto LoadHot Start!")
	if time.Now().Unix() == timeZeroStr.Unix() {
		//0点会自动发布一次数据
		if err = s.SetHotPub(ctx, "crontabLoadHot", 0); err != nil {
			log.Error("searchSrv.LoadHot SetHotPub error(%v)", err)
			return
		}
		log.Info("searchSrv.LoadHot Auto LoadHot Success! 00:00 clock")
	} else if time.Now().Unix() >= timeTwelveStr.Unix() {
		log.Info("searchSrv.LoadHot Auto LoadHot Time > (%v)", timeTwelveStr)
		if status, err = s.isTodayAutoPubHot(ctx); err != nil {
			log.Error("searchSrv.LoadHot isTodayAutoPubHot error(%v)", err)
			return
		}
		log.Info("searchSrv.LoadHot Auto LoadHot Publish Status = (%v)", status)
		if status {
			return
		}
		if err = s.SetHotPub(ctx, "crontabLoadHot", 0); err != nil {
			log.Error("searchSrv.LoadHot SetHotPub error(%v)", err)
			return
		}
		log.Info("searchSrv.LoadHot Auto LoadHot Success! more than 12:00 clock")
	}
}

//LoadDark crontab auto load dark word
func (s *Service) LoadDark() {
	var (
		status bool
		err    error
	)
	log.Info("searchSrv.LoadDark Auto LoadDark Start!")
	timeTwelve := time.Now().Format("2006-01-02 ") + "12:00:00"
	timeTwelveStr, _ := s.parseTime(timeTwelve, "2006-01-02 15:04:05")
	timeZero := time.Now().Format("2006-01-02 ") + "00:00:00"
	timeZeroStr, _ := s.parseTime(timeZero, "2006-01-02 15:04:05")
	log.Info("searchSrv.LoadDark Auto LoadDark Start!")
	if time.Now().Unix() == timeZeroStr.Unix() {
		//0点会自动发布一次数据
		if err = s.SetDarkPub(ctx, "crontabLoadDark", 0); err != nil {
			log.Error("searchSrv.LoadDark SetDarkPub error(%v)", err)
			return
		}
		log.Info("searchSrv.LoadDark Auto LoadDark Success! 00:00 clock")
	} else if time.Now().Unix() >= timeTwelveStr.Unix() {
		log.Info("searchSrv.LoadDark Auto LoadDark Time > (%v)", timeTwelveStr)
		if status, err = s.isTodayAutoPubDark(ctx); err != nil {
			log.Error("searchSrv.LoadDark isTodayAutoPubDark error(%v)", err)
			return
		}
		log.Info("searchSrv.LoadDark Auto LoadDark Publish Status = (%v)", status)
		if status {
			return
		}
		if err = s.SetDarkPub(ctx, "crontabLoadDark", 0); err != nil {
			log.Error("searchSrv.LoadDark SetDarkPub error(%v)", err)
			return
		}
		log.Info("searchSrv.LoadDark Auto LoadDark Success!")
	}
}

//isTodayAutoPubHot is today publish hot word
func (s *Service) isTodayAutoPubHot(c context.Context) (status bool, err error) {
	var (
		flag bool
		date string
	)
	if flag, date, err = s.dao.GetSearchAuditStat(c, _HotAutoPubState); err != nil {
		log.Error("searchSrv.isTodayAutoPubHot GetPubState error(%v)", err)
		return
	}
	//已发布 且是今天发布的数据 则证明今天发布过
	if flag && date == time.Now().Format("2006-01-02") {
		return true, nil
	}
	return
}

//isTodayAutoPubHot is today publish hot word
func (s *Service) isTodayAutoPubDark(c context.Context) (status bool, err error) {
	var (
		flag bool
		date string
	)
	if flag, date, err = s.dao.GetSearchAuditStat(c, _DarkAutoPubState); err != nil {
		log.Error("searchSrv.isTodayAutoPubDark GetPubState error(%v)", err)
		return
	}
	//已发布 且是今天发布的数据 则证明今天发布过
	if flag && date == time.Now().Format("2006-01-02") {
		return true, nil
	}
	return
}

//parseTime parse string to unix timestamp
func (s *Service) parseTime(t string, timeLayout string) (theTime time.Time, err error) {
	//timeLayout := "2006-01-02 15:04:05"
	//timeLayout := "2006-01-02" //转化所需模板

	loc, _ := time.LoadLocation("Local") //重要：获取时区
	//使用模板在对应时区转化为time.time类型
	if theTime, err = time.ParseInLocation(timeLayout, t, loc); err != nil {
		log.Error("searchSrv.parseTime ParseInLocation(%v) error(%v)", t, err)
		return
	}
	return
}

//GetSearchValue 获取搜索的数据
func (s *Service) GetSearchValue(date string, blackSlice []string) (his []searchModel.History, err error) {
	if err = s.dao.DB.Model(&searchModel.History{}).
		Where("atime = ?", date).Where("searchword not in (?)", blackSlice).
		Where("deleted = ?", searchModel.NotDelete).
		Find(&his).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.GetSearchValue error(%v)", err)
		return
	}
	return
}

//GetSearHisValue 获取搜索热词的数据
func (s *Service) GetSearHisValue(blackSlice []string) (his []searchModel.History, err error) {
	var hisTmp searchModel.History
	if err = s.dao.DB.Model(&searchModel.History{}).
		Where("deleted = ?", searchModel.NotDelete).Order("atime desc").Limit(1).
		First(&hisTmp).Error; err != nil {
		log.Error("searchSrv.GetSearchHisValue Last Day error(%v)", err)
		return
	}
	dao := s.dao.DB.Model(&searchModel.History{}).
		Where("atime = ?", hisTmp.Atime)
	if len(blackSlice) > 0 {
		dao = dao.Where("searchword not in (?)", blackSlice)
	}
	if err = dao.Where("deleted = ?", searchModel.NotDelete).Find(&his).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.GetSearchHisValue error(%v)", err)
		return
	}
	return
}

//HotwordFromDB 从DB中取有效数据
func (s *Service) HotwordFromDB(date string) (hot []searchModel.Intervene, searchCount int, err error) {
	var (
		black      []searchModel.Black
		blackSlice []string
		his        []searchModel.History
	)
	if black, err = s.BlackList(); err != nil {
		log.Error("searchSrv.HotList Black error(%v)", err)
		return
	}
	for _, v := range black {
		blackSlice = append(blackSlice, v.Searchword)
	}
	his, err = s.GetSearchValue(date, blackSlice)
	if err != nil {
		log.Error("searchSrv.HotwordFromDB error(%v)", err)
		return
	}
	searchCount = len(his)
	//如果是取今天发布的数据 且没有取到 则以昨天的为准
	if time.Now().Format("2006-01-02") == date && len(his) == 0 {
		//如果 当天的搜索热词暂未同步过来 则取昨天的搜索热词
		if his, err = s.GetSearHisValue(blackSlice); err != nil {
			log.Error("searchSrv.HotList GetHotPubLog error(%v)", err)
			return
		}
	}
	//未结束的运营干预词
	if err = s.dao.DB.Model(&searchModel.Intervene{}).Where("etime >= ?", date).Where("searchword not in (?)", blackSlice).
		Where("deleted = ?", searchModel.NotDelete).
		Find(&hot).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.HotList Intervene error(%v)", err)
		return
	}
	//搜索历史词 默认position为-1
	for _, v := range his {
		var (
			inter = searchModel.Intervene{}
		)
		//判断搜索词是否在干预中
		if err = s.dao.DB.Model(&searchModel.Intervene{}).Where("etime >= ?", date).Where("searchword = ?", v.Searchword).
			Where("deleted = ?", searchModel.NotDelete).
			First(&inter).Error; err != nil && err != gorm.ErrRecordNotFound {
			log.Error("searchSrv.HotwordFromDB Intervene First error(%v)", err)
			return
		}
		//没有找到 则直接添加搜索的热词数据
		if err == gorm.ErrRecordNotFound {
			i := searchModel.Intervene{
				ID:         v.ID,
				Searchword: v.Searchword,
				Rank:       -1,
				Tag:        v.Tag,
				Pv:         v.Pv,
			}
			hot = append(hot, i)
		} else {
			//找到 则直接将PV值复制到运营词的数据
			for j, k := range hot {
				if k.Searchword == v.Searchword {
					hot[j].Pv = v.Pv
				}
			}
		}
	}
	return hot, searchCount, nil
}

//GetDarkValue 获取搜索热词的数据
func (s *Service) GetDarkValue(blackSlice []string) (his []searchModel.Dark, err error) {
	var darkTmp searchModel.Dark
	if err = s.dao.DB.Model(&searchModel.Dark{}).
		Where("deleted = ?", searchModel.NotDelete).Order("atime desc").Limit(1).
		First(&darkTmp).Error; err != nil {
		log.Error("searchSrv.GetDarkValue Last Day error(%v)", err)
		return
	}
	dao := s.dao.DB.Model(&searchModel.Dark{}).
		Where("atime = ?", darkTmp.Atime)
	if len(blackSlice) > 0 {
		dao = dao.Where("searchword not in (?)", blackSlice)
	}
	if err = dao.Where("deleted = ?", searchModel.NotDelete).Find(&his).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.GetDarkValue error(%v)", err)
		return
	}
	return
}

//DarkwordFromDB 从DB中取有效数据
func (s *Service) DarkwordFromDB(date string) (darkValue []searchModel.Dark, searchCount int, err error) {
	var (
		black      []searchModel.Black
		blackSlice []string
		dark       []searchModel.Dark
	)
	if black, err = s.BlackList(); err != nil {
		log.Error("searchSrv.DarkwordFromDB BlackList error(%v)", err)
	}
	for _, v := range black {
		blackSlice = append(blackSlice, v.Searchword)
	}
	if err = s.dao.DB.Model(&searchModel.Dark{}).Where("deleted = ?", searchModel.NotDelete).
		Where("atime = ?", date).Where("deleted = ?", searchModel.NotDelete).Find(&dark).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.DarkwordFromDB Find error(%v)", err)
		return
	}
	searchCount = len(dark)
	if err = s.dao.DB.Model(&searchModel.Dark{}).Where("deleted = ?", searchModel.NotDelete).
		Where("atime = ?", date).Where("searchword not in (?)", blackSlice).
		Where("deleted = ?", searchModel.NotDelete).Find(&dark).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.DarkwordFromDB Find error(%v)", err)
		return
	}
	//若搜索没有推黑马词过来 则以昨天的数据为准
	if time.Now().Format("2006-01-02") == date && len(dark) == 0 {
		if dark, err = s.GetDarkValue(blackSlice); err != nil {
			log.Error("searchSrv.DarkwordFromDB GetDarkPubLog error(%v)", err)
			return
		}
	}
	m := make(map[string]bool)
	for _, val := range dark {
		if _, ok := m[val.Searchword]; !ok {
			m[val.Searchword] = true
			darkValue = append(darkValue, val)
		}
	}
	return
}

//OpenHotList open hotword list
func (s *Service) OpenHotList(c *bm.Context) (hotout []searchModel.Intervene, err error) {
	var (
		hot []searchModel.Intervene
	)
	if hot, err = s.GetHotPub(c); err != nil {
		log.Error("searchSrv.OpenHotList GetHotPub error(%v)", err)
		return
	}
	cTime := time.Now().Unix()
	inter := map[string]bool{}
	for _, v := range hot {
		if v.Rank != -1 && cTime >= v.Stime.Time().Unix() && cTime <= v.Etime.Time().Unix() {
			//运营词
			inter[v.Searchword] = true
		}
	}
	for _, v := range hot {
		if v.Rank == -1 {
			//如果运营词已存在 则以运营词为准
			if _, flag := inter[v.Searchword]; flag {
				continue
			}
			//-1 是ai的数据 直接添加
			hotout = append(hotout, v)
		} else if cTime >= v.Stime.Time().Unix() && cTime <= v.Etime.Time().Unix() {
			hotout = append(hotout, v)
		}
	}
	return
}

//HotList hotword list
func (s *Service) HotList(c *bm.Context, t string) (hotout searchModel.HotwordOut, err error) {
	var (
		dateStamp  time.Time
		todayStamp time.Time
		flag       bool
		hot        []searchModel.Intervene
		date       string
	)
	if dateStamp, err = s.parseTime(t, "2006-01-02"); err != nil {
		return
	}
	today := time.Unix(time.Now().Unix(), 0).Format("2006-01-02")
	if todayStamp, err = s.parseTime(today, "2006-01-02"); err != nil {
		return
	}
	if flag, date, err = s.dao.GetSearchAuditStat(c, _HotPubState); err != nil {
		log.Error("searchSrv.HotList GetPublishCache error(%v)", err)
		return
	}
	//过去的时间 则直接从日志中取数据
	if dateStamp.Unix() < todayStamp.Unix() {
		var logFlag bool
		if hotout.Hotword, logFlag, err = s.GetHotPubLog(t); err != nil {
			log.Error("searchSrv.HotList GetHotPubLog error(%v)", err)
			return
		}
		if logFlag {
			hotout.State = _HotShowPub
		} else {
			hotout.State = _HotShowUnpub
		}
		return
	}
	//公共的逻辑
	if hot, _, err = s.HotwordFromDB(t); err != nil {
		log.Error("searchSrv.HotList HotwordFromDB error(%v)", err)
		return
	}
	hotout.Hotword = hot
	//今天的数据
	if dateStamp.Unix() == todayStamp.Unix() {
		//已发布 且是今天发布的数据
		if flag && date == time.Now().Format("2006-01-02") {
			//2.判断发布的时候 是否有搜索数据过来
			var pubStatus bool
			if pubStatus, _, err = s.dao.GetSearchAuditStat(c, _HotPubSearchState); err != nil {
				log.Error("searchSrv.SetHotPub SetSearchPubStat error(%v)", err)
				return
			}
			if pubStatus {
				//发布的时候 有搜索的数据 提示上线
				hotout.State = _HotShowPub
			} else {
				//发布的是 没有搜索的数据 提示 未更新
				hotout.State = _HotShowUnUp
			}
			return
		}
		//未发布
		hotout.State = _HotShowUnpub
		return
	}
	//未来的数据 都是未发布的
	hotout.State = _HotShowUnpub
	return
}

//DarkList darkword list
func (s *Service) DarkList(c *bm.Context, t string) (darkout searchModel.DarkwordOut, err error) {
	var (
		dateStamp  time.Time
		todayStamp time.Time
		flag       bool
		//flagAuto   bool
		dark []searchModel.Dark
		date string
	)
	if dateStamp, err = s.parseTime(t, "2006-01-02"); err != nil {
		return
	}
	today := time.Unix(time.Now().Unix(), 0).Format("2006-01-02")
	if todayStamp, err = s.parseTime(today, "2006-01-02"); err != nil {
		return
	}
	if flag, date, err = s.dao.GetSearchAuditStat(c, _DarkPubState); err != nil {
		log.Error("searchSrv.DarkList GetPublishCache error(%v)", err)
		return
	}
	//过去的时间 则直接从日志中取数据
	if dateStamp.Unix() < todayStamp.Unix() {
		var logFlag bool
		if darkout.Darkword, logFlag, err = s.GetDarkPubLog(t); err != nil {
			log.Error("searchSrv.HotList GetHotPubLog error(%v)", err)
			return
		}
		if logFlag {
			darkout.State = _DarkShowPub
		} else {
			darkout.State = _DarkShowUnpub
		}
		return
	}
	//公共的逻辑
	if dark, _, err = s.DarkwordFromDB(t); err != nil {
		log.Error("searchSrv.DarkList HotwordFromDB error(%v)", err)
		return
	}
	darkout.Darkword = dark
	//今天的数据
	if dateStamp.Unix() == todayStamp.Unix() {
		//已发布 且是今天发布的数据 则直接取缓存数据
		if flag && date == time.Now().Format("2006-01-02") {
			//判断发布的时候 是否有搜索数据过来
			var pubStatus bool
			if pubStatus, _, err = s.dao.GetSearchAuditStat(c, _DarkPubSearchState); err != nil {
				log.Error("searchSrv.DarkList GetPubState error(%v)", err)
				return
			}
			if pubStatus {
				//发布的时候 有搜索的数据 提示上线
				darkout.State = _DarkShowPub
			} else {
				//发布的是 没有搜索的数据 提示 未更新
				darkout.State = _DarkShowUnUp
			}
			return
		}
		//未更新
		darkout.State = _DarkShowUnpub
		return
	}
	//未来的数据 都是未发布的
	darkout.State = _HotShowUnpub
	return
}

//BlackList black list
func (s *Service) BlackList() (black []searchModel.Black, err error) {
	if err = s.dao.DB.Model(&searchModel.Black{}).
		Where("deleted = ?", searchModel.NotDelete).Find(&black).Error; err != nil {
		log.Error("searchSrv.History Index error(%v)", err)
		return
	}
	return
}

//DelBlack add black
func (s *Service) DelBlack(c *bm.Context, id int, person string, uid int64) (err error) {
	var (
		black searchModel.Black
	)
	//根据id查找热词
	if err = s.dao.DB.Model(&searchModel.Black{}).
		Where("id = ?", id).First(&black).Error; err != nil {
		log.Error("searchSrv.DelBlack Black First error(%v)", err)
		return
	}
	if err = s.dao.DB.Model(&searchModel.Black{}).
		Where("id = ?", id).Update("deleted", searchModel.Delete).Error; err != nil {
		log.Error("searchSrv.DelBlack Update error(%v)", err)
		return
	}
	//更新AI热词为删除状态
	if err = s.dao.DB.Model(&searchModel.History{}).
		Where("searchword = ?", black.Searchword).Update("deleted", searchModel.Delete).Error; err != nil {
		log.Error("searchSrv.DelBlack Update History error(%v)", err)
		return
	}
	//更新运营热词为删除状态
	if err = s.dao.DB.Model(&searchModel.Intervene{}).
		Where("searchword = ?", black.Searchword).Update("deleted", searchModel.Delete).Error; err != nil {
		log.Error("searchSrv.DelBlack Update error(%v)", err)
		return
	}
	//更新黑马词为删除状态
	if err = s.dao.DB.Model(&searchModel.Dark{}).
		Where("searchword = ?", black.Searchword).Update("deleted", searchModel.Delete).Error; err != nil {
		log.Error("searchSrv.DelBlack Update error(%v)", err)
		return
	}
	//设置黑名单之后 立即发布新数据
	if err = s.SetHotPub(c, person, uid); err != nil {
		return
	}
	if err = s.SetDarkPub(c, person, uid); err != nil {
		return
	}
	obj := map[string]interface{}{
		"id": id,
	}
	if err = Log.AddLog(searchModel.Business, person, uid, int64(id), searchModel.ActionDelBlack, obj); err != nil {
		log.Error("searchSrv.DelBlack AddLog error(%v)", err)
		return
	}
	return
}

//AddBlack add black
func (s *Service) AddBlack(c *bm.Context, black string, person string, uid int64) (err error) {
	var (
		word searchModel.Black
	)
	if err = s.dao.DB.Model(&searchModel.Black{}).
		Where("deleted = ?", searchModel.NotDelete).Where("searchword = ?", black).
		First(&word).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.AddBlack get First error(%v)", err)
		return
	}
	if err != gorm.ErrRecordNotFound {
		err = fmt.Errorf("黑名单已存在")
		return
	}
	w := searchModel.AddBlack{
		Searchword: black,
	}
	if err = s.dao.DB.Model(&searchModel.Black{}).
		Create(w).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.AddBlack Create error(%v)", err)
		return
	}
	//设置黑名单之后 立即发布新数据
	if err = s.SetHotPub(c, person, uid); err != nil {
		return
	}
	if err = s.SetDarkPub(c, person, uid); err != nil {
		return
	}
	obj := map[string]interface{}{
		"blackword": word,
	}
	if err = Log.AddLog(searchModel.Business, person, uid, 0, searchModel.ActionAddBlack, obj); err != nil {
		log.Error("searchSrv.AddBlack AddLog error(%v)", err)
		return
	}
	return
}

//checkBlack checkout blacklist
func (s *Service) checkBlack(word string) (state bool, err error) {
	var (
		black searchModel.Black
	)
	if err = s.dao.DB.Model(&searchModel.Black{}).
		Where("deleted = ?", searchModel.NotDelete).Where("searchword = ?", word).
		First(&black).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.checkBlack get First error(%v)", err)
		return
	}
	if err == gorm.ErrRecordNotFound {
		return false, nil
	}
	return true, nil
}

//checkInter checkout intervene
func (s *Service) checkInter(word string, id int) (state bool, err error) {
	var (
		intervene searchModel.Intervene
	)
	dataStr := time.Unix(time.Now().Unix(), 0).Format("2006-01-02 15:04:05")
	query := s.dao.DB.Model(&searchModel.Intervene{}).
		Where("searchword = ?", word)
	if id != 0 {
		query = query.Where("id != ?", id)
	}
	//取未删除且结束时间大于当前时间的词
	query = query.Where("deleted = ?", searchModel.NotDelete).Where("etime > ?", dataStr)
	if err = query.First(&intervene).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.checkInter get First error(%v)", err)
		return
	}
	if err == gorm.ErrRecordNotFound {
		return false, nil
	}
	return true, nil
}

//checkTimeConflict checkout intervene time conflict
func (s *Service) checkTimeConflict(i searchModel.InterveneAdd, id int) (state bool, err error) {
	var (
		c          int
		black      []searchModel.Black
		blackSlice []string
	)
	if black, err = s.BlackList(); err != nil {
		log.Error("searchSrv.HotList Black error(%v)", err)
	}
	for _, v := range black {
		blackSlice = append(blackSlice, v.Searchword)
	}
	query := s.dao.DB.Model(&searchModel.Intervene{}).
		Where("rank = ?", i.Rank).
		Where("stime < ?", i.Etime).
		Where("etime > ?", i.Stime).
		Where("searchword not in (?)", blackSlice).
		Where("deleted = ?", searchModel.NotDelete)
	if id != 0 {
		query = query.Where("id != ?", id)
	}
	if err = query.Count(&c).Error; err != nil {
		log.Error("searchSrv.checkTimeConflict Count error(%v)", err)
		return
	}
	if c > 0 {
		return true, nil
	}
	return false, nil
}

//AddInter add intervene word
func (s *Service) AddInter(c *bm.Context, v searchModel.InterveneAdd, person string, uid int64) (err error) {
	var (
		state bool
	)
	if state, err = s.checkBlack(v.Searchword); err != nil {
		log.Error("searchSrv.addInter checkBlack error(%v)", err)
		return
	}
	if state {
		err = fmt.Errorf("所添加的词在黑名单中已存在")
		return
	}
	if state, err = s.checkInter(v.Searchword, 0); err != nil {
		log.Error("searchSrv.addInter checkBlack error(%v)", err)
		return
	}
	if state {
		err = fmt.Errorf("干预词已存在")
		return
	}
	if state, err = s.checkTimeConflict(v, 0); err != nil {
		log.Error("searchSrv.addInter checkTimeConflict error(%v)", err)
		return
	}
	if state {
		err = fmt.Errorf("相同时间内，该位置已存在搜索词")
		return
	}
	if err = s.dao.DB.Model(&searchModel.InterveneAdd{}).Create(&v).Error; err != nil {
		log.Error("searchSrv.AddIntervene Create error(%v)", err)
		return
	}
	s.dao.SetSearchAuditStat(c, _HotPubState, false)
	if err = s.dao.SetSearchAuditStat(c, _HotPubState, false); err != nil {
		log.Error("searchSrv.DelBlack SetPubStat error(%v)", err)
		return
	}
	obj := map[string]interface{}{
		"value": v,
	}
	if err = Log.AddLog(searchModel.Business, person, uid, 0, searchModel.ActionAddInter, obj); err != nil {
		log.Error("searchSrv.addInter AddLog error(%v)", err)
		return
	}
	return
}

//UpdateInter update intervene word
func (s *Service) UpdateInter(c *bm.Context, v searchModel.InterveneAdd, id int, person string, uid int64) (err error) {
	var (
		state bool
	)
	if state, err = s.checkBlack(v.Searchword); err != nil {
		log.Error("searchSrv.UpdateInter checkBlack error(%v)", err)
		return
	}
	if state {
		err = fmt.Errorf("所添加的词在黑名单中已存在")
		return
	}
	if state, err = s.checkInter(v.Searchword, id); err != nil {
		log.Error("searchSrv.UpdateInter checkInter error(%v)", err)
		return
	}
	if state {
		err = fmt.Errorf("干预词已存在")
		return
	}
	if state, err = s.checkTimeConflict(v, id); err != nil {
		log.Error("searchSrv.UpdateInter checkTimeConflict error(%v)", err)
		return
	}
	if state {
		err = fmt.Errorf("相同时间内，该位置已存在搜索词")
		return
	}
	if v.Tag == "" {
		v2 := map[string]interface{}{
			"searchword": v.Searchword,
			"rank":       v.Rank,
			"tag":        v.Tag,
			"stime":      v.Stime,
			"etime":      v.Etime,
		}
		if err = s.dao.DB.Model(&searchModel.InterveneAdd{}).
			Where("id = ?", id).Updates(v2).Error; err != nil {
			log.Error("searchSrv.UpdateInter Update error(%v)", err)
			return
		}
	} else {
		if err = s.dao.DB.Model(&searchModel.InterveneAdd{}).
			Where("id = ?", id).Updates(&v).Error; err != nil {
			log.Error("searchSrv.UpdateInter Update error(%v)", err)
			return
		}
	}

	if err = s.dao.SetSearchAuditStat(c, _HotPubState, false); err != nil {
		log.Error("searchSrv.DelBlack SetPubStat error(%v)", err)
		return
	}
	obj := map[string]interface{}{
		"value": v,
		"id":    id,
	}
	if err = Log.AddLog(searchModel.Business, person, uid, int64(id), searchModel.ActionUpdateInter, obj); err != nil {
		log.Error("searchSrv.addInter AddLog error(%v)", err)
		return
	}
	return
}

//UpdateSearch update search hot tag
func (s *Service) UpdateSearch(c *bm.Context, tag string, id int, person string, uid int64) (err error) {
	if err = s.dao.DB.Model(&searchModel.History{}).
		Where("id = ?", id).Update("tag", tag).Error; err != nil {
		log.Error("searchSrv.UpdateSearch Update error(%v)", err)
		return
	}
	if err = s.dao.SetSearchAuditStat(c, _HotPubState, false); err != nil {
		log.Error("searchSrv.DelBlack SetPubStat error(%v)", err)
		return
	}
	obj := map[string]interface{}{
		"value": tag,
		"id":    id,
	}
	if err = Log.AddLog(searchModel.Business, person, uid, int64(id), searchModel.ActionUpdateSearch, obj); err != nil {
		log.Error("searchSrv.UpdateSearch AddLog error(%v)", err)
		return
	}
	return
}

//DeleteHot delete hot word
func (s *Service) DeleteHot(c context.Context, id int, t uint8, person string, uid int64) (err error) {
	if t == searchModel.HotAI {
		//删除AI热词
		if err = s.dao.DB.Model(&searchModel.History{}).
			Where("id = ?", id).Update("deleted", searchModel.Delete).Error; err != nil {
			log.Error("searchSrv.DeleteHot Update AI error(%v)", err)
			return
		}
	} else if t == searchModel.HotOpe {
		//删除运营热词
		if err = s.dao.DB.Model(&searchModel.Intervene{}).
			Where("id = ?", id).Update("deleted", searchModel.Delete).Error; err != nil {
			log.Error("searchSrv.DeleteHot Update Operate error(%v)", err)
			return
		}
	}
	//删除热词之后 立即发布新数据
	if err = s.SetHotPub(c, person, uid); err != nil {
		return
	}
	obj := map[string]interface{}{
		"type": t,
		"id":   id,
	}
	if err = Log.AddLog(searchModel.Business, person, uid, int64(id), searchModel.ActionDeleteHot, obj); err != nil {
		log.Error("searchSrv.DeleteHot AddLog error(%v)", err)
		return
	}
	return
}

//DeleteDark delete dark word
func (s *Service) DeleteDark(c context.Context, id int, person string, uid int64) (err error) {
	if err = s.dao.DB.Model(&searchModel.Dark{}).
		Where("id = ?", id).Update("deleted", searchModel.Delete).Error; err != nil {
		log.Error("searchSrv.DeleteDark Update error(%v)", err)
		return
	}
	if err = s.SetDarkPub(c, person, uid); err != nil {
		return
	}
	obj := map[string]interface{}{
		"id": id,
	}
	if err = Log.AddLog(searchModel.Business, person, uid, int64(id), searchModel.ActionDeleteDark, obj); err != nil {
		log.Error("searchSrv.DeleteDark AddLog error(%v)", err)
		return
	}
	return
}

//OpenAddDarkword open api for search add dark word
func (s *Service) OpenAddDarkword(c context.Context, values searchModel.OpenDark) (err error) {
	if err = s.dao.DB.Model(&searchModel.Dark{}).
		Where("atime = ?", values.Date).Update("deleted", searchModel.Delete).Error; err != nil {
		log.Error("searchSrv.OpenAddDarkword Update error(%v)", err)
		return
	}
	for _, v := range values.Values {
		dark := searchModel.Dark{
			Searchword: v.Searchword,
			PV:         v.PV,
			Atime:      values.Date,
		}
		if err = s.dao.DB.Model(&searchModel.Dark{}).Create(&dark).Error; err != nil {
			log.Error("searchSrv.OpenAddDarkword Create error(%v)", err)
			return
		}
	}
	//如果有黑马词同步过来 则更新发布状态为false
	if err = s.dao.SetSearchAuditStat(c, _DarkAutoPubState, false); err != nil {
		log.Error("searchSrv.DelBlack SetPubStat error(%v)", err)
		return
	}
	obj := map[string]interface{}{
		"value": values,
	}
	if err = Log.AddLog(searchModel.Business, "SEARCH", 0, 0, searchModel.ActionOpenAddDark, obj); err != nil {
		log.Error("searchSrv.OpenAddDarkword AddLog error(%v)", err)
		return
	}
	return
}

//OpenAddHotword open api for search add hotword
func (s *Service) OpenAddHotword(c *bm.Context, values searchModel.OpenHot) (err error) {
	if err = s.dao.DB.Model(&searchModel.Hot{}).Where("atime = ?", values.Date).Delete(&searchModel.Hot{}).Error; err != nil {
		log.Error("searchSrv.OpenAddHotword Delete error(%v)", err)
		return
	}
	for _, v := range values.Values {
		hot := searchModel.Hot{
			Searchword: v.Searchword,
			PV:         v.PV,
			Atime:      values.Date,
		}
		if err = s.dao.DB.Model(&searchModel.Hot{}).Create(&hot).Error; err != nil {
			log.Error("searchSrv.OpenAddHotword Create error(%v)", err)
			return
		}
	}
	//如果有搜索热词同步过来 则更新自动发布状态为false
	if err = s.dao.SetSearchAuditStat(c, _HotAutoPubState, false); err != nil {
		log.Error("searchSrv.DelBlack SetPubStat error(%v)", err)
		return
	}
	obj := map[string]interface{}{
		"value": values,
	}
	if err = Log.AddLog(searchModel.Business, "SEARCH", 0, 0, searchModel.ActionOpenAddHot, obj); err != nil {
		log.Error("searchSrv.OpenAddHotword AddLog error(%v)", err)
		return
	}
	return
}

//GetHotPub get hotword publish from mc
func (s *Service) GetHotPub(c *bm.Context) (hot []searchModel.Intervene, err error) {
	var (
		conn memcache.Conn
		item *memcache.Item
	)
	conn = s.dao.MC.Get(c)
	defer conn.Close()
	if item, err = conn.Get(_HotPubValue); err != nil {
		if err == memcache.ErrNotFound {
			return nil, nil
		}
		return
	}
	if err = conn.Scan(item, &hot); err != nil {
		return
	}
	return
}

//GetDarkPub get darkword publish from mc
func (s *Service) GetDarkPub(c *bm.Context) (dark []searchModel.Dark, err error) {
	var (
		conn memcache.Conn
		item *memcache.Item
	)
	conn = s.dao.MC.Get(c)
	defer conn.Close()
	if item, err = conn.Get(_DarkPubValue); err != nil {
		if err == memcache.ErrNotFound {
			return nil, nil
		}
		return
	}
	if err = conn.Scan(item, &dark); err != nil {
		return
	}
	return
}

//SetHotPub set hotword publish to mc
func (s *Service) SetHotPub(c context.Context, person string, uid int64) (err error) {
	var (
		conn        memcache.Conn
		hot         []searchModel.Intervene
		searchCount int
	)
	conn = s.dao.MC.Get(c)
	defer conn.Close()
	//只能发布当天的数据
	//从DB中取今天的数据
	if hot, searchCount, err = s.HotwordFromDB(time.Now().Format("2006-01-02")); err != nil {
		log.Error("searchSrv.SetHoGetSearHisValuetPub HotwordFromDB error(%v)", err)
		return
	}
	itemJSON := &memcache.Item{
		Key:        _HotPubValue,
		Flags:      memcache.FlagJSON,
		Object:     hot,
		Expiration: 0,
	}
	if err = conn.Set(itemJSON); err != nil {
		log.Error("searchSrv.SetHotPub conn.Set error(%v)", err)
		return
	}
	if searchCount == 0 {
		//证明搜索没有推数据过来 设置搜索的数据为假
		if err = s.dao.SetSearchAuditStat(c, _HotPubSearchState, false); err != nil {
			log.Error("searchSrv.SetHotPub SetSearchPubStat error(%v)", err)
			return
		}
	} else {
		//证明搜索有推数据过来 设置搜索的数据为真
		if err = s.dao.SetSearchAuditStat(c, _HotPubSearchState, true); err != nil {
			log.Error("searchSrv.SetHotPub SetSearchPubStat error(%v)", err)
			return
		}
	}
	//设置自动发布状态为true
	if err = s.dao.SetSearchAuditStat(c, _HotAutoPubState, true); err != nil {
		log.Error("searchSrv.SetHotPub SetPubStat error(%v)", err)
		return
	}
	//设置运营发布状态为true
	if err = s.dao.SetSearchAuditStat(c, _HotPubState, true); err != nil {
		log.Error("searchSrv.SetHotPub SetPubStat error(%v)", err)
		return
	}
	obj := map[string]interface{}{
		"value": hot,
	}
	if err = Log.AddLog(searchModel.Business, person, uid, 0, searchModel.ActionPublishHot, obj); err != nil {
		log.Error("searchSrv.SetHotPub AddLog error(%v)", err)
		return
	}
	if err = s.HotPubLog(hot); err != nil {
		log.Error("searchSrv.SetHotPub HotPubLog error(%v)", err)
		return
	}
	return
}

//HotPubLog hotword publish log
func (s *Service) HotPubLog(hot []searchModel.Intervene) (err error) {
	t := time.Now().Unix()
	for _, v := range hot {
		w := searchModel.HotPubLog{
			Searchword: v.Searchword,
			Position:   v.Rank,
			Pv:         v.Pv,
			Tag:        v.Tag,
			Stime:      v.Stime,
			Etime:      v.Etime,
			Atime:      time.Now().Format("2006-01-02"),
			Groupid:    t,
		}
		if err = s.dao.DB.Model(&searchModel.HotPubLog{}).Create(&w).Error; err != nil {
			log.Error("searchSrv.DarkPubLog Create error(%v)", err)
			return
		}
	}
	return
}

//GetHotPubLog get hotword publish log
func (s *Service) GetHotPubLog(date string) (hotout []searchModel.Intervene, pub bool, err error) {
	var (
		//hotout searchModel.HotwordOut
		logs []searchModel.HotPubLog
	)
	l := searchModel.HotPubLog{}
	if err = s.dao.DB.Model(&searchModel.HotPubLog{}).Where("atime = ?", date).Order("groupid desc").
		First(&l).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.GetHotPubLog First error(%v)", err)
		return
	}
	//证明没有发布过
	if err == gorm.ErrRecordNotFound {
		return nil, false, nil
	}
	//取最大的groupid的值
	if err = s.dao.DB.Model(&searchModel.HotPubLog{}).Where("groupid = ?", l.Groupid).
		Find(&logs).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.GetHotPubLog Find error(%v)", err)
		return
	}
	for _, v := range logs {
		a := searchModel.Intervene{
			Searchword: v.Searchword,
			Rank:       v.Position,
			Pv:         v.Pv,
			Tag:        v.Tag,
			Stime:      v.Stime,
			Etime:      v.Etime,
		}
		hotout = append(hotout, a)
	}
	return hotout, true, nil
}

//GetDarkPubLog get darkword publish log
func (s *Service) GetDarkPubLog(date string) (darkout []searchModel.Dark, pub bool, err error) {
	var (
		//hotout searchModel.HotwordOut
		logs []searchModel.DarkPubLog
	)
	l := searchModel.DarkPubLog{}
	if err = s.dao.DB.Model(&searchModel.DarkPubLog{}).Where("atime = ?", date).Order("groupid desc").
		First(&l).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.GetDarkPubLog First error(%v)", err)
		return
	}
	//证明没有发布过
	if err == gorm.ErrRecordNotFound {
		return nil, false, nil
	}
	//取最大的groupid的值
	if err = s.dao.DB.Model(&searchModel.DarkPubLog{}).Where("groupid = ?", l.Groupid).
		Find(&logs).Error; err != nil && err != gorm.ErrRecordNotFound {
		log.Error("searchSrv.GetDarkPubLog Find error(%v)", err)
		return
	}
	for _, v := range logs {
		a := searchModel.Dark{
			Searchword: v.Searchword,
			PV:         v.Pv,
		}
		darkout = append(darkout, a)
	}
	return darkout, true, nil
}

//SetDarkPub set darkword to mc
func (s *Service) SetDarkPub(c context.Context, person string, uid int64) (err error) {
	var (
		conn        memcache.Conn
		dark        []searchModel.Dark
		searchCount int
	)
	conn = s.dao.MC.Get(c)
	defer conn.Close()
	//只能发布当天的数据
	//从DB中取今天的数据
	if dark, searchCount, err = s.DarkwordFromDB(time.Now().Format("2006-01-02")); err != nil {
		log.Error("searchSrv.SetHotPub HotwordFromDB error(%v)", err)
		return
	}
	itemJSON := &memcache.Item{
		Key:        _DarkPubValue,
		Flags:      memcache.FlagJSON,
		Object:     dark,
		Expiration: 0,
	}
	if err = conn.Set(itemJSON); err != nil {
		log.Error("searchSrv.SetHotPub conn.Set error(%v)", err)
		return
	}
	if searchCount == 0 {
		//证明搜索没有推数据过来 设置搜索的数据为假
		if err = s.dao.SetSearchAuditStat(c, _DarkPubSearchState, false); err != nil {
			log.Error("searchSrv.SetDarkPub SetSearchPubStat error(%v)", err)
			return
		}
	} else {
		//证明搜索有推数据过来 设置搜索的数据为真
		if err = s.dao.SetSearchAuditStat(c, _DarkPubSearchState, true); err != nil {
			log.Error("searchSrv.SetDarkPub SetSearchPubStat error(%v)", err)
			return
		}
	}
	if err = s.dao.SetSearchAuditStat(c, _DarkPubState, true); err != nil {
		log.Error("searchSrv.SetHotPub SetPubStat error(%v)", err)
		return
	}
	if err = s.dao.SetSearchAuditStat(c, _DarkAutoPubState, true); err != nil {
		log.Error("searchSrv.SetHotPub SetPubStat error(%v)", err)
		return
	}
	obj := map[string]interface{}{
		"value": dark,
	}
	if err = Log.AddLog(searchModel.Business, person, uid, 0, searchModel.ActionPublishDark, obj); err != nil {
		log.Error("searchSrv.SetDarkPub AddLog error(%v)", err)
		return
	}
	if err = s.DarkPubLog(dark); err != nil {
		log.Error("searchSrv.SetDarkPub DarkPubLog error(%v)", err)
		return
	}
	return
}

//DarkPubLog get darkword publish log
func (s *Service) DarkPubLog(dark []searchModel.Dark) (err error) {
	t := time.Now().Unix()
	for _, v := range dark {
		w := searchModel.DarkPubLog{
			Searchword: v.Searchword,
			Pv:         v.PV,
			Atime:      time.Now().Format("2006-01-02"),
			Groupid:    t,
		}
		if err = s.dao.DB.Model(&searchModel.DarkPubLog{}).Create(&w).Error; err != nil {
			log.Error("searchSrv.DarkPubLog Create error(%v)", err)
			return
		}
	}
	return
}