You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
224 lines
6.5 KiB
224 lines
6.5 KiB
package service |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
|
|
artmdl "go-common/app/interface/openplatform/article/model" |
|
"go-common/app/job/openplatform/article/dao" |
|
"go-common/app/job/openplatform/article/model" |
|
"go-common/library/conf/env" |
|
"go-common/library/log" |
|
) |
|
|
|
func (s *Service) upArticles(c context.Context, action string, newMsg []byte, oldMsg []byte) { |
|
log.Info("s.upArticles action(%s) old(%s) new(%s)", action, string(oldMsg), string(newMsg)) |
|
if action != model.ActUpdate && action != model.ActInsert && action != model.ActDelete { |
|
return |
|
} |
|
var ( |
|
err error |
|
aid int64 |
|
newArticle = &model.Article{} |
|
oldArticle = &model.Article{} |
|
) |
|
if err = json.Unmarshal(newMsg, newArticle); err != nil { |
|
log.Error("json.Unmarshal(%s) error(%+v)", newMsg, err) |
|
dao.PromError("article:解析过审文章databus新内容") |
|
return |
|
} |
|
if action == model.ActUpdate { |
|
if err = json.Unmarshal(oldMsg, oldArticle); err != nil { |
|
log.Error("json.Unmarshal(%s) error(%+v)", oldMsg, err) |
|
dao.PromError("article:解析过审文章databus旧内容") |
|
return |
|
} |
|
} |
|
aid = newArticle.ID |
|
mid := newArticle.Mid |
|
show := true |
|
var comment string |
|
if artmdl.NoDistributeAttr(newArticle.Attributes) { |
|
show = false |
|
comment = "禁止分发" |
|
} |
|
switch action { |
|
case model.ActInsert: |
|
s.openReply(c, aid, mid) |
|
s.addArtCache(c, aid) |
|
s.updateSearchArt(c, newArticle) |
|
s.flowSync(c, aid, mid) |
|
s.addURLNode(c, aid) |
|
if comment == "" { |
|
comment = "文章过审" |
|
} |
|
case model.ActUpdate: |
|
s.updateArtCache(c, aid, oldArticle.CategoryID) |
|
s.addURLNode(c, aid) |
|
if !artmdl.NoDistributeAttr(oldArticle.Attributes) && artmdl.NoDistributeAttr(newArticle.Attributes) { |
|
s.delSearchArt(c, aid) |
|
} else { |
|
s.updateSearchArt(c, newArticle) |
|
} |
|
if comment == "" { |
|
comment = "文章修改" |
|
} |
|
case model.ActDelete: |
|
s.closeReply(c, aid, mid) |
|
s.deleteArtCache(c, aid, mid) |
|
s.deleteArtRecommendCache(c, aid, newArticle.CategoryID) |
|
s.delSearchArt(c, aid) |
|
// s.delMediaScore(c, aid, newArticle.MediaID, mid) |
|
show = false |
|
comment = "文章不可见" |
|
} |
|
if e := s.dao.PubDynamic(c, mid, aid, show, comment, int64(newArticle.PublishTime), newArticle.DynamicIntro); e != nil { |
|
s.dao.PushDynamicCache(c, &model.DynamicCacheRetry{ |
|
Aid: aid, |
|
Mid: mid, |
|
Show: show, |
|
Comment: comment, |
|
Ts: int64(newArticle.PublishTime), |
|
DynamicIntro: newArticle.DynamicIntro, |
|
}) |
|
} |
|
if env.DeployEnv != env.DeployEnvProd { |
|
return |
|
} |
|
s.gameSync(c, aid, mid, action) |
|
urls := model.ReadURLs(aid) |
|
for _, u := range urls { |
|
if err = s.dao.PurgeCDN(c, u); err == nil { |
|
log.Info("s.dao.PurgeCDN(%s) success.", u) |
|
dao.PromInfo("article:刷新CDN") |
|
} |
|
} |
|
} |
|
|
|
func (s *Service) gameSync(c context.Context, aid, mid int64, action string) { |
|
authors, err := s.dao.GameList(c) |
|
if err != nil { |
|
dao.PromError("service:获得游戏数据") |
|
log.Error("s.gameSync(aid: %v, mid: %v) init err: %+v", aid, mid, err) |
|
return |
|
} |
|
var exist bool |
|
for _, author := range authors { |
|
if author == mid { |
|
exist = true |
|
break |
|
} |
|
} |
|
if !exist { |
|
return |
|
} |
|
if err = s.dao.GameSync(c, action, aid); err != nil { |
|
log.Error("s.gameSync(%d, %d, %s) error(%+v)", aid, mid, action, err) |
|
dao.PromError("service:同步游戏数据") |
|
s.dao.PushGameCache(c, &model.GameCacheRetry{ |
|
Action: action, |
|
Aid: aid, |
|
}) |
|
return |
|
} |
|
log.Info("s.gameSync(%d, %d, %s) success", aid, mid, action) |
|
} |
|
|
|
func (s *Service) flowSync(c context.Context, aid, mid int64) { |
|
if err := s.dao.FlowSync(c, mid, aid); err != nil { |
|
s.dao.PushFlowCache(c, &model.FlowCacheRetry{ |
|
Aid: aid, |
|
Mid: mid, |
|
}) |
|
return |
|
} |
|
log.Info("s.flowSync(aid: %d, mid: %d) success", aid, mid) |
|
} |
|
|
|
func (s *Service) openReply(c context.Context, aid, mid int64) (err error) { |
|
if err = s.dao.OpenReply(c, aid, mid); err == nil { |
|
log.Info("OpenReply(%d,%d) success.", aid, mid) |
|
dao.PromInfo("article:打开评论区") |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) closeReply(c context.Context, aid, mid int64) (err error) { |
|
if err = s.dao.CloseReply(c, aid, mid); err == nil { |
|
log.Info("CloseReply(%d,%d) success.", aid, mid) |
|
dao.PromInfo("article:关闭评论区") |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) addArtCache(c context.Context, aid int64) (err error) { |
|
arg := &artmdl.ArgAid{Aid: aid} |
|
if err = s.articleRPC.AddArticleCache(c, arg); err != nil { |
|
log.Error("s.articleRPC.AddArticleCache(%d) error(%+v)", aid, err) |
|
dao.PromError("article:新增文章缓存") |
|
s.dao.PushArtCache(c, &dao.CacheRetry{ |
|
Action: dao.RetryAddArtCache, |
|
Aid: aid, |
|
}) |
|
} else { |
|
log.Info("s.articleRPC.AddArticleCache(%d) success", aid) |
|
dao.PromInfo("article:新增文章缓存") |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) updateArtCache(c context.Context, aid, cid int64) (err error) { |
|
arg := &artmdl.ArgAidCid{Aid: aid, Cid: cid} |
|
if err = s.articleRPC.UpdateArticleCache(c, arg); err != nil { |
|
log.Error("s.articleRPC.UpdateArticleCache(%d,%d) error(%+v)", aid, cid, err) |
|
dao.PromError("article:更新文章缓存") |
|
s.dao.PushArtCache(c, &dao.CacheRetry{ |
|
Action: dao.RetryUpdateArtCache, |
|
Aid: aid, |
|
Cid: cid, |
|
}) |
|
} else { |
|
log.Info("s.articleRPC.UpdateArticleCache(%d,%d) success", aid, cid) |
|
dao.PromInfo("article:更新文章缓存") |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) deleteArtCache(c context.Context, aid, mid int64) (err error) { |
|
arg := &artmdl.ArgAidMid{Aid: aid, Mid: mid} |
|
if err = s.articleRPC.DelArticleCache(c, arg); err != nil { |
|
log.Error("s.articleRPC.DelArticleCache(%d,%d) error(%+v)", aid, mid, err) |
|
dao.PromError("article:删除文章缓存") |
|
s.dao.PushArtCache(c, &dao.CacheRetry{ |
|
Action: dao.RetryDeleteArtCache, |
|
Aid: aid, |
|
Mid: mid, |
|
}) |
|
} else { |
|
log.Info("s.articleRPC.DelArticleCache(%d,%d) success", aid, mid) |
|
dao.PromInfo("article:删除文章缓存") |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) deleteArtRecommendCache(c context.Context, aid, cid int64) (err error) { |
|
arg := &artmdl.ArgAidCid{Aid: aid, Cid: cid} |
|
if err = s.articleRPC.DelRecommendArtCache(c, arg); err != nil { |
|
log.Error("s.articleRPC.DelRecommendArtCache(%d,%d) error(%+v)", aid, cid, err) |
|
dao.PromError("article:删除文章推荐缓存") |
|
s.dao.PushArtCache(c, &dao.CacheRetry{ |
|
Action: dao.RetryDeleteArtRecCache, |
|
Aid: aid, |
|
Cid: cid, |
|
}) |
|
} else { |
|
log.Info("s.articleRPC.DelRecommendArtCache(%d,%d) success", aid, cid) |
|
dao.PromInfo("article:删除文章推荐缓存") |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) delMediaScore(c context.Context, aid, mediaID, mid int64) (err error) { |
|
err = s.dao.DelScore(c, aid, mediaID, mid) |
|
return |
|
}
|
|
|