openbilibili/app/interface/openplatform/article/service/creation.go

package service

import (
	"context"
	"sort"

	"go-common/app/interface/openplatform/article/dao"
	"go-common/app/interface/openplatform/article/model"
	"go-common/library/database/sql"
	"go-common/library/ecode"
	"go-common/library/log"

	"go-common/library/sync/errgroup"
)

const (
	_sortDefault    = 0
	_sortByCtime    = 1
	_sortByLike     = 2
	_sortByReply    = 3
	_sortByView     = 4
	_sortByFavorite = 5
	_sortByCoin     = 6

	//_stateCancel 取消活动
	// _stateCancel = -1
	//_stateJoin 参加活动
	_stateJoin = 0

	_editTimes = 1
)

// checkPrivilege check that whether user has permission to write article.
func (s *Service) checkPrivilege(c context.Context, mid int64) (err error) {
	if res, _, e := s.IsAuthor(c, mid); !res {
		err = ecode.ArtCreationNoPrivilege
		if e != nil {
			dao.PromError("creation:检查作者权限")
		}
	}
	return
}

func (s *Service) checkArtAuthor(c context.Context, aid, mid int64) (am *model.Meta, err error) {
	if am, err = s.creationArticleMeta(c, aid); err != nil {
		return
	} else if am == nil {
		err = ecode.NothingFound
		return
	}
	if am.Author.Mid != mid {
		err = ecode.ArtCreationMIDErr
	}
	return
}

// CreationArticle get creation article
func (s *Service) creationArticleMeta(c context.Context, aid int64) (am *model.Meta, err error) {
	if am, err = s.dao.CreationArticleMeta(c, aid); err != nil {
		dao.PromError("creation:获取文章meta")
		return
	} else if am == nil {
		return
	}
	if s.categoriesMap[am.Category.ID] != nil {
		am.Category = s.categoriesMap[am.Category.ID]
	}
	var author *model.Author
	if author, _ = s.author(c, am.Author.Mid); author != nil {
		am.Author = author
	}
	return
}

// CreationArticle .
func (s *Service) CreationArticle(c context.Context, aid, mid int64) (a *model.Article, err error) {
	if err = s.checkPrivilege(c, mid); err != nil {
		return
	}
	var (
		content string
		am      *model.Meta
	)
	a = &model.Article{}
	if am, err = s.checkArtAuthor(c, aid, mid); err != nil {
		return
	}
	if am.State == model.StateRePending || am.State == model.StateReReject {
		if a, err = s.ArticleVersion(c, aid); err != nil {
			return
		}
		a.Author = am.Author
		a.Category = s.categoriesMap[a.Category.ID]
		a.List, _ = s.dao.ArtList(c, aid)
		a.Stats, _ = s.stat(c, aid)
		return
	}
	group, errCtx := errgroup.WithContext(c)
	group.Go(func() (err error) {
		content, err = s.dao.CreationArticleContent(c, aid)
		return
	})
	group.Go(func() (err error) {
		am.Stats, _ = s.stat(errCtx, aid)
		return
	})
	group.Go(func() (err error) {
		am.Tags, _ = s.Tags(errCtx, aid, true)
		return
	})
	group.Go(func() (err error) {
		am.List, _ = s.dao.ArtList(errCtx, aid)
		return
	})
	if err = group.Wait(); err != nil {
		return
	}
	a.Meta = am
	a.Content = content
	log.Info("s.CreationArticle() aid(%d) title(%s) content length(%d)", a.ID, a.Title, len(a.Content))
	return
}

// AddArticle adds article.
func (s *Service) AddArticle(c context.Context, a *model.Article, actID, listID int64, ip string) (id int64, err error) {
	log.Info("s.AddArticle() aid(%d) title(%s) actID(%d) content length(%d)", a.ID, a.Title, actID, len(a.Content))
	defer func() {
		if err != nil && err != ecode.CreativeArticleCanNotRepeat {
			s.dao.DelSubmitCache(c, a.Author.Mid, a.Title)
		}
	}()
	if err = s.checkPrivilege(c, a.Author.Mid); err != nil {
		return
	}
	a.Content = xssFilter(a.Content)
	if err = s.preArticleCheck(c, a); err != nil {
		return
	}
	var num int
	if num, err = s.ArticleRemainCount(c, a.Author.Mid); err != nil {
		return
	} else if num <= 0 {
		err = ecode.ArtCreationArticleFull
		return
	}
	if s.checkList(c, a.Author.Mid, listID); err != nil {
		return
	}
	a.State = model.StatePending
	var tx *sql.Tx
	if tx, err = s.dao.BeginTran(c); err != nil {
		log.Error("tx.BeginTran() error(%+v)", err)
		return
	}
	defer func() {
		if err != nil {
			if err1 := tx.Rollback(); err1 != nil {
				log.Error("tx.Rollback() error(%+v)", err1)
			}
			return
		}
		if err = tx.Commit(); err != nil {
			dao.PromError("creation:添加文章")
			log.Error("tx.Commit() error(%+v)", err)
			return
		}
		// id is article id
		if e1 := s.creativeAddArticleList(c, a.Meta.Author.Mid, listID, id, false); e1 != nil {
			dao.PromError("creation:添加文章绑定文集")
			log.Errorv(c, log.KV("log", "creativeAddArticleList"), log.KV("mid", a.Meta.Author.Mid), log.KV("listID", listID), log.KV("article_id", id), log.KV("error", err))
		}
	}()
	// del draft
	if err = s.dao.TxDeleteArticleDraft(c, tx, a.Author.Mid, a.ID); err != nil {
		dao.PromError("creation:删除草稿")
		return
	}
	if id, err = s.dao.TxAddArticleMeta(c, tx, a.Meta, actID); err != nil {
		dao.PromError("creation:删除文章meta")
		return
	}
	keywords, _ := s.Segment(c, int32(id), a.Content, 1, "article")
	if err = s.dao.TxAddArticleContent(c, tx, id, a.Content, keywords); err != nil {
		dao.PromError("creation:添加文章content")
		return
	}
	// add version
	if err = s.dao.TxAddArticleVersion(c, tx, id, a, actID); err != nil {
		dao.PromError("creation:添加历史记录")
		return
	}
	if actID > 0 {
		if e := s.dao.HandleActivity(c, a.Author.Mid, id, actID, _stateJoin, ip); e != nil {
			log.Error("creation: s.act.HandleActivity mid(%d) aid(%d) actID(%d) ip(%s) error(%+v)", a.Author.Mid, id, actID, ip, e)
		}
	}
	var tags []string
	for _, t := range a.Tags {
		tags = append(tags, t.Name)
	}
	if err = s.BindTags(c, a.Meta.Author.Mid, id, tags, ip, actID); err != nil {
		dao.PromError("creation:发布文章绑定tag")
	}
	return
}

// UpdateArticle update article.
func (s *Service) UpdateArticle(c context.Context, a *model.Article, actID, listID int64, ip string) (err error) {
	log.Info("s.UpdateArticle() aid(%d) title(%s) content length(%d)", a.ID, a.Title, len(a.Content))
	if err = s.checkPrivilege(c, a.Author.Mid); err != nil {
		return
	}
	a.Content = xssFilter(a.Content)
	if err = s.preArticleCheck(c, a); err != nil {
		return
	}
	a.State = model.StatePending
	if a.ID <= 0 {
		err = ecode.ArtCreationIDErr
		return
	}
	if _, err = s.checkArtAuthor(c, a.ID, a.Author.Mid); err != nil {
		return
	}
	//这里转换成 -2 2 几种状态
	if err = s.convertState(c, a); err != nil {
		return
	}
	if a.State == model.StateRePending {
		err = s.updateArticleVersion(c, a, actID)
		return
	}
	if err = s.updateArticleDB(c, a); err != nil {
		return
	}
	var tags []string
	for _, t := range a.Tags {
		tags = append(tags, t.Name)
	}
	s.BindTags(c, a.Meta.Author.Mid, a.Meta.ID, tags, ip, actID)
	s.CreativeUpdateArticleList(c, a.Meta.Author.Mid, a.ID, listID, false)
	return
}

func (s *Service) updateArticleVersion(c context.Context, a *model.Article, actID int64) (err error) {
	var tx *sql.Tx
	if tx, err = s.dao.BeginTran(c); err != nil {
		log.Error("updateArticleVersion.tx.BeginTran() error(%+v)", err)
		return
	}
	defer func() {
		if err != nil {
			if err1 := tx.Rollback(); err1 != nil {
				log.Error("updateArticleVersion.tx.Rollback() error(%+v)", err1)
			}
			return
		}
		if err = tx.Commit(); err != nil {
			log.Error("updateArticleVersion.tx.Commit() error(%+v)", err)
			return
		}
	}()
	if err = s.dao.TxUpdateArticleStateApplyTime(c, tx, a.ID, a.State); err != nil {
		dao.PromError("creation:修改文章状态")
		return
	}

	if x, e := s.ArticleVersion(c, a.ID); e == nil && x.ID != 0 {
		if err = s.dao.TxUpdateArticleVersion(c, tx, a.ID, a, actID); err != nil {
			dao.PromError("creation:更新版本")
		}
	} else {
		if err = s.dao.TxAddArticleVersion(c, tx, a.ID, a, actID); err != nil {
			dao.PromError("creation:创建版本")
		}
	}
	// if err = s.dao.TxUpdateArticleVersion(c, tx, a.ID, a, actID); err != nil {
	// 	dao.PromError("creation:更新版本")
	// }
	return
}

func (s *Service) updateArticleDB(c context.Context, a *model.Article) (err error) {
	var tx *sql.Tx
	if tx, err = s.dao.BeginTran(c); err != nil {
		log.Error("tx.BeginTran() error(%+v)", err)
		return
	}
	if err = s.dao.TxUpdateArticleMeta(c, tx, a.Meta); err != nil {
		if err1 := tx.Rollback(); err1 != nil {
			dao.PromError("creation:更新文章meta")
			log.Error("tx.Rollback() error(%+v)", err1)
		}
		return
	}
	keywords, _ := s.Segment(c, int32(a.ID), a.Content, 1, "article")
	if err = s.dao.TxUpdateArticleContent(c, tx, a.ID, a.Content, keywords); err != nil {
		if err1 := tx.Rollback(); err1 != nil {
			dao.PromError("creation:更新文章content")
			log.Error("tx.Rollback() error(%+v)", err1)
		}
		return
	}
	// add version
	if err = s.dao.TxUpdateArticleVersion(c, tx, a.ID, a, 0); err != nil {
		dao.PromError("creation:添加历史记录")
		return
	}
	if err = tx.Commit(); err != nil {
		dao.PromError("creation:更新文章")
		log.Error("tx.Commit() error(%+v)", err)
	}
	return
}

// DelArticle drops article.
func (s *Service) DelArticle(c context.Context, aid, mid int64) (err error) {
	if aid <= 0 {
		err = ecode.ArtCreationIDErr
		return
	}
	if err = s.checkPrivilege(c, mid); err != nil {
		return
	}
	var a *model.Meta
	if a, err = s.checkArtAuthor(c, aid, mid); err != nil {
		return
	}
	// can not delelte article which state is pending.
	if a.State == model.StatePending || a.State == model.StateOpenPending {
		err = ecode.ArtCreationDelPendingErr
		return
	}
	lists, _ := s.dao.RawArtsListID(c, []int64{aid})
	if err = s.delArticle(c, aid); err != nil {
		return
	}
	s.dao.DelActivity(c, aid, "")
	cache.Save(func() {
		c := context.TODO()
		s.dao.DelRecommend(c, aid)
		s.DelRecommendArtCache(c, aid, a.Category.ID)
		s.DelArticleCache(c, mid, aid)
		s.deleteArtsListCache(c, aid)
		if lists[aid] > 0 {
			s.updateListInfo(c, lists[aid])
			s.RebuildListCache(c, lists[aid])
		}
	})
	return
}

func (s *Service) delArticle(c context.Context, aid int64) (err error) {
	var tx *sql.Tx
	if tx, err = s.dao.BeginTran(c); err != nil {
		log.Error("tx.BeginTran() error(%+v)", err)
		return
	}
	defer func() {
		if err != nil {
			if err1 := tx.Rollback(); err1 != nil {
				log.Error("tx.Rollback() error(%+v)", err1)
			}
			return
		}
		if err = tx.Commit(); err != nil {
			dao.PromError("creation:删除文章")
			log.Error("tx.Commit() error(%+v)", err)
		}
	}()
	if err = s.dao.TxDeleteArticleMeta(c, tx, aid); err != nil {
		dao.PromError("creation:删除文章meta")
		return
	}
	if err = s.dao.TxDeleteArticleContent(c, tx, aid); err != nil {
		dao.PromError("creation:delete文章content")
		return
	}
	if err = s.dao.TxDelFilteredArtMeta(c, tx, aid); err != nil {
		dao.PromError("creation:删除过滤文章meta")
		return
	}
	if err = s.dao.TxDelFilteredArtContent(c, tx, aid); err != nil {
		dao.PromError("creation:删除过滤文章content")
		return
	}
	if err = s.dao.TxDelArticleList(tx, aid); err != nil {
		return
	}
	if err = s.dao.TxDelArticleVersion(c, tx, aid); err != nil {
		return
	}
	return
}

// CreationUpperArticlesMeta gets article list by mid.
func (s *Service) CreationUpperArticlesMeta(c context.Context, mid int64, group, category, sortType, pn, ps int, ip string) (res *model.CreationArts, err error) {
	res = &model.CreationArts{}
	if err = s.checkPrivilege(c, mid); err != nil {
		return
	}
	var (
		aids    []int64
		ams, as []*model.Meta
		stats   = make(map[int64]*model.Stats)
		start   = (pn - 1) * ps
		end     = start + ps - 1
		total   int
	)
	res.Page = &model.ArtPage{
		Pn: pn,
		Ps: ps,
	}
	eg, errCtx := errgroup.WithContext(c)
	eg.Go(func() (err error) {
		res.Type, _ = s.dao.UpperArticlesTypeCount(errCtx, mid)
		return
	})
	eg.Go(func() (err error) {
		if ams, err = s.dao.UpperArticlesMeta(errCtx, mid, group, category); err != nil {
			return
		}
		total = len(ams)
		res.Page.Total = total
		return
	})
	if err = eg.Wait(); err != nil {
		log.Error("eg.Wait() error(%+v)", err)
		return
	}
	if total == 0 || total < start {
		return
	}
	for _, v := range ams {
		aids = append(aids, v.ID)
	}
	if stats, err = s.stats(c, aids); err != nil {
		dao.PromError("creation:获取计数信息")
		log.Error("s.stats(%v) err: %+v", aids, err)
		err = nil
	}
	for _, v := range ams {
		// stats
		if st := stats[v.ID]; st != nil {
			v.Stats = st
		} else {
			v.Stats = new(model.Stats)
		}
	}
	switch sortType {
	case _sortDefault, _sortByCtime:
		sort.Slice(ams, func(i, j int) bool { return ams[i].Ctime > ams[j].Ctime })
	case _sortByLike:
		sort.Slice(ams, func(i, j int) bool { return ams[i].Stats.Like > ams[j].Stats.Like })
	case _sortByReply:
		sort.Slice(ams, func(i, j int) bool { return ams[i].Stats.Reply > ams[j].Stats.Reply })
	case _sortByView:
		sort.Slice(ams, func(i, j int) bool { return ams[i].Stats.View > ams[j].Stats.View })
	case _sortByFavorite:
		sort.Slice(ams, func(i, j int) bool { return ams[i].Stats.Favorite > ams[j].Stats.Favorite })
	case _sortByCoin:
		sort.Slice(ams, func(i, j int) bool { return ams[i].Stats.Coin > ams[j].Stats.Coin })
	}
	if total > end {
		as = ams[start : end+1]
	} else {
		as = ams[start:]
	}
	for _, v := range as {
		var pid int64
		if pid, err = s.CategoryToRoot(v.Category.ID); err != nil {
			dao.PromError("creation:获取根分区")
			log.Error("s.CategoryToRoot(%d) error(%+v)", v.Category.ID, err)
			continue
		}
		v.Category = s.categoriesMap[pid]
		v.List, _ = s.dao.ArtList(c, v.ID)
	}
	res.Articles = as
	return
}

// convertState converts -1 to 1, -2 to 2 if the article had been published.
func (s *Service) convertState(c context.Context, a *model.Article) (err error) {
	var am *model.Meta
	if am, err = s.dao.CreationArticleMeta(c, a.ID); err != nil {
		return
	}
	if am.State == model.StateOpen || am.State == model.StateRePass || am.State == model.StateReReject {
		if s.EditTimes(c, a.ID) <= 0 {
			err = ecode.ArtUpdateFullErr
			return
		}
		a.State = model.StateRePending
		return
	}
	if (am.State != model.StateReject) && (am.State != model.StateOpenReject) {
		err = ecode.ArtCannotEditErr
		return
	}
	if am.State > 0 && a.State < 0 {
		a.State = -a.State
	}
	return
}

// CreationWithdrawArticle recall the article and add it to draft.
func (s *Service) CreationWithdrawArticle(c context.Context, mid, aid int64) (err error) {
	if err = s.checkPrivilege(c, mid); err != nil {
		return
	}
	var am *model.Meta
	if am, err = s.checkArtAuthor(c, aid, mid); err != nil {
		return
	}
	// 只有初次提交待审的文章才可以撤回，发布后的修改待审不允许撤回
	if am.State != model.StatePending {
		err = ecode.ArtCreationStateErr
		return
	}
	var content string
	if content, err = s.dao.CreationArticleContent(c, aid); err != nil {
		return
	}
	// add draft
	var tags []string
	if ts, e := s.Tags(c, aid, false); e == nil && len(ts) > 0 {
		for _, v := range ts {
			tags = append(tags, v.Name)
		}
	}
	am.ID = 0
	draft := &model.Draft{Article: &model.Article{Meta: am, Content: content}, Tags: tags}
	if _, err = s.AddArtDraft(c, draft); err != nil {
		return
	}
	// delete article
	err = s.delArticle(c, aid)
	// err = s.dao.UpdateArticleState(c, aid, model.StateOpen)
	return
}

// UpStat up stat
func (s *Service) UpStat(c context.Context, mid int64) (res model.UpStat, err error) {
	return s.dao.UpStat(c, mid)
}

// UpThirtyDayStat for 30 days stat.
func (s *Service) UpThirtyDayStat(c context.Context, mid int64) (res []*model.ThirtyDayArticle, err error) {
	res, err = s.dao.ThirtyDayArticle(c, mid)
	return
}

// ArticleUpCover article upload cover.
func (s *Service) ArticleUpCover(c context.Context, fileType string, body []byte) (url string, err error) {
	if len(body) == 0 {
		err = ecode.FileNotExists
		return
	}
	if len(body) > s.c.BFS.MaxFileSize {
		err = ecode.FileTooLarge
		return
	}
	url, err = s.dao.UploadImage(c, fileType, body)
	if err != nil {
		log.Error("creation: s.bfs.Upload error(%v)", err)
	}
	return
}

// ArticleVersion .
func (s *Service) ArticleVersion(c context.Context, aid int64) (a *model.Article, err error) {
	if a, err = s.dao.ArticleVersion(c, aid); err != nil {
		return
	}
	a.Category = s.categoriesMap[a.Category.ID]
	return
}

// EditTimes .
func (s *Service) EditTimes(c context.Context, id int64) (res int) {
	var (
		et    = _editTimes
		count = et
		err   error
	)
	if s.c.Article.EditTimes != 0 {
		et = s.c.Article.EditTimes
	}
	if count, err = s.dao.EditTimes(c, id); err != nil {
		return
	}
	res = et - count
	if res < 0 {
		res = 0
	}
	return
}

func (s *Service) lastReason(c context.Context, id int64, state int32) (res string, err error) {
	return s.dao.LastReason(c, id, state)
}