xing/wp-go
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

优化代码，及打印错误日志

Browse Source
This commit is contained in:
xing 2022-09-27 15:35:34 +08:00
parent 10efcc9711
commit 086de50dcf
6 changed files with 133 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
actions/common/common.go
View File

@ -5,18 +5,15 @@ import (
"database/sql"
"fmt"
"github/fthvgb1/wp-go/cache"
"github/fthvgb1/wp-go/logs"
"github/fthvgb1/wp-go/models"
"github/fthvgb1/wp-go/vars"
"log"
"strconv"
"strings"
"sync"
"time"
)
var PostsCache sync.Map
var PostContextCache sync.Map
var postContextCache *cache.MapCache[uint64, PostContext]
var archivesCaches *Arch
var categoryCaches *cache.SliceCache[models.WpTermsMy]
var recentPostsCaches *cache.SliceCache[models.WpPosts]
@ -29,6 +26,9 @@ func InitActionsCommonCache() {
mutex: &sync.Mutex{},
setCacheFunc: archives,
}
postContextCache = cache.NewMapCache[uint64, PostContext](getPostContext, vars.Conf.ContextPostCacheTime)
postsCache = cache.NewMapBatchCache[uint64, models.WpPosts](getPosts, time.Hour)
categoryCaches = cache.NewSliceCache[models.WpTermsMy](categories, vars.Conf.CategoryCacheTime)
@ -52,7 +52,7 @@ func (c *Arch) getArchiveCache() []models.PostArchive {
if l > 0 && c.month != m || l < 1 {
r, err := c.setCacheFunc()
if err != nil {
log.Printf("set cache err[%s]", err)
logs.ErrPrintln(err, "set cache err[%s]")
return nil
}
c.mutex.Lock()
@ -64,10 +64,8 @@ func (c *Arch) getArchiveCache() []models.PostArchive {
}
type PostContext struct {
Prev models.WpPosts
Next models.WpPosts
expireTime time.Duration
setTime time.Time
prev models.WpPosts
next models.WpPosts
}
func PostComments(ctx context.Context, Id uint64) ([]models.WpComments, error) {
@ -86,7 +84,8 @@ func postComments(args ...any) ([]models.WpComments, error) {
}
func RecentComments(ctx context.Context) (r []models.WpComments) {
r, _ = recentCommentsCaches.GetCache(ctx, time.Second)
r, err := recentCommentsCaches.GetCache(ctx, time.Second)
logs.ErrPrintln(err, "get recent comment")
return
}
func recentComments(...any) (r []models.WpComments, err error) {
@ -98,48 +97,30 @@ func recentComments(...any) (r []models.WpComments, err error) {
}, 5)
}
func getMonthPost(args ...any) ([]models.WpPosts, error) {
y := args[0].(string)
m := args[1].(string)
where := models.SqlBuilder{
{"post_type", "in", ""},
{"post_status", "in", ""},
{"month(post_date)", m},
{"year(post_date)", y},
func GetContextPost(ctx context.Context, id uint64, date time.Time) (prev, next models.WpPosts, err error) {
postCtx, err := postContextCache.GetCache(ctx, id, time.Second, date)
if err != nil {
return models.WpPosts{}, models.WpPosts{}, err
}
return models.Find[models.WpPosts](where, "ID", "",
models.SqlBuilder{{"post_date", "asc"}},
nil, 0, []any{"post"}, []any{"publish"},
)
}
func GetContextPost(id uint64, t time.Time) (prev, next models.WpPosts, err error) {
post, ok := PostContextCache.Load(id)
if ok {
c := post.(PostContext)
isExp := c.expireTime/time.Second+time.Duration(c.setTime.Unix()) < time.Duration(time.Now().Unix())
if !isExp && (c.Prev.Id > 0 || c.Next.Id > 0) {
return c.Prev, c.Next, nil
}
}
prev, next, err = getPostContext(t)
post = PostContext{
Prev: prev,
Next: next,
expireTime: vars.Conf.ContextPostCacheTime,
setTime: time.Now(),
}
PostContextCache.Store(id, post)
prev = postCtx.prev
next = postCtx.next
return
}
func getPostContext(t time.Time) (prev, next models.WpPosts, err error) {
next, err = models.FirstOne[models.WpPosts](models.SqlBuilder{
func getPostContext(arg ...any) (r PostContext, err error) {
t := arg[0].(time.Time)
next, err := models.FirstOne[models.WpPosts](models.SqlBuilder{
{"post_date", ">", t.Format("2006-01-02 15:04:05")},
{"post_status", "in", ""},
{"post_type", "post"},
}, "ID,post_title,post_password", nil, []any{"publish", "private"})
prev, err = models.FirstOne[models.WpPosts](models.SqlBuilder{
if err == sql.ErrNoRows {
err = nil
}
if err != nil {
return
}
prev, err := models.FirstOne[models.WpPosts](models.SqlBuilder{
{"post_date", "<", t.Format("2006-01-02 15:04:05")},
{"post_status", "in", ""},
{"post_type", "post"},
@ -147,62 +128,12 @@ func getPostContext(t time.Time) (prev, next models.WpPosts, err error) {
if err == sql.ErrNoRows {
err = nil
}
return
}
func QueryAndSetPostCache(postIds []models.WpPosts) (err error) {
var all []uint64
var needQuery []any
for _, wpPosts := range postIds {
all = append(all, wpPosts.Id)
if _, ok := PostsCache.Load(wpPosts.Id); !ok {
needQuery = append(needQuery, wpPosts.Id)
}
if err != nil {
return
}
if len(needQuery) > 0 {
rawPosts, er := models.Find[models.WpPosts](models.SqlBuilder{{
"Id", "in", "",
}}, "a.*,ifnull(d.name,'') category_name,ifnull(taxonomy,'') `taxonomy`", "", nil, models.SqlBuilder{{
"a", "left join", "wp_term_relationships b", "a.Id=b.object_id",
}, {
"left join", "wp_term_taxonomy c", "b.term_taxonomy_id=c.term_taxonomy_id",
}, {
"left join", "wp_terms d", "c.term_id=d.term_id",
}}, 0, needQuery)
if er != nil {
err = er
return
}
postsMap := make(map[uint64]*models.WpPosts)
for i, post := range rawPosts {
v, ok := postsMap[post.Id]
if !ok {
v = &rawPosts[i]
}
if post.Taxonomy == "category" {
v.Categories = append(v.Categories, post.CategoryName)
} else if post.Taxonomy == "post_tag" {
v.Tags = append(v.Tags, post.CategoryName)
}
postsMap[post.Id] = v
}
for _, pp := range postsMap {
if len(pp.Categories) > 0 {
t := make([]string, 0, len(pp.Categories))
for _, cat := range pp.Categories {
t = append(t, fmt.Sprintf(`<a href="/p/category/%s" rel="category tag">%s</a>`, cat, cat))
}
pp.CategoriesHtml = strings.Join(t, "、")
}
if len(pp.Tags) > 0 {
t := make([]string, 0, len(pp.Tags))
for _, cat := range pp.Tags {
t = append(t, fmt.Sprintf(`<a href="/p/tag/%s" rel="tag">%s</a>`, cat, cat))
}
pp.TagsHtml = strings.Join(t, "、")
}
PostsCache.Store(pp.Id, pp)
}
r = PostContext{
prev: prev,
next: next,
}
return
}
@ -218,7 +149,8 @@ func Archives() (r []models.PostArchive) {
}
func Categories(ctx context.Context) []models.WpTermsMy {
r, _ := categoryCaches.GetCache(ctx, time.Second)
r, err := categoryCaches.GetCache(ctx, time.Second)
logs.ErrPrintln(err, "get category ")
return r
}
@ -244,7 +176,8 @@ func categories(...any) (terms []models.WpTermsMy, err error) {
}
func RecentPosts(ctx context.Context) (r []models.WpPosts) {
r, _ = recentPostsCaches.GetCache(ctx, time.Second)
r, err := recentPostsCaches.GetCache(ctx, time.Second)
logs.ErrPrintln(err, "get recent post")
return
}
func recentPosts(...any) (r []models.WpPosts, err error) {

50
actions/common/posts.go
View File

@ -2,16 +2,30 @@ package common
import (
"context"
"fmt"
"github/fthvgb1/wp-go/helper"
"github/fthvgb1/wp-go/models"
"strings"
"time"
)
func GetPostById(ctx context.Context, id uint64, ids ...uint64) (models.WpPosts, error) {
func GetPostAndCache(ctx context.Context, id uint64, ids ...uint64) (models.WpPosts, error) {
return postsCache.GetCacheBatch(ctx, id, time.Second, ids)
}
func GetPost(id uint64) models.WpPosts {
return postsCache.Get(id)
}
func SetPostCache(ids []models.WpPosts) error {
var arg []uint64
for _, posts := range ids {
arg = append(arg, posts.Id)
}
return postsCache.SetByBatchFn(arg)
}
func getPosts(ids ...any) (m map[uint64]models.WpPosts, err error) {
m = make(map[uint64]models.WpPosts)
id := ids[0].([]uint64)
@ -25,10 +39,38 @@ func getPosts(ids ...any) (m map[uint64]models.WpPosts, err error) {
}, {
"left join", "wp_terms d", "c.term_id=d.term_id",
}}, 0, arg)
if err == nil {
for _, v := range rawPosts {
m[v.Id] = v
if err != nil {
return m, err
}
postsMap := make(map[uint64]models.WpPosts)
for i, post := range rawPosts {
v, ok := postsMap[post.Id]
if !ok {
v = rawPosts[i]
}
if post.Taxonomy == "category" {
v.Categories = append(v.Categories, post.CategoryName)
} else if post.Taxonomy == "post_tag" {
v.Tags = append(v.Tags, post.CategoryName)
}
postsMap[post.Id] = v
}
for k, pp := range postsMap {
if len(pp.Categories) > 0 {
t := make([]string, 0, len(pp.Categories))
for _, cat := range pp.Categories {
t = append(t, fmt.Sprintf(`<a href="/p/category/%s" rel="category tag">%s</a>`, cat, cat))
}
pp.CategoriesHtml = strings.Join(t, "、")
}
if len(pp.Tags) > 0 {
t := make([]string, 0, len(pp.Tags))
for _, cat := range pp.Tags {
t = append(t, fmt.Sprintf(`<a href="/p/tag/%s" rel="tag">%s</a>`, cat, cat))
}
pp.TagsHtml = strings.Join(t, "、")
}
m[k] = pp
}
return
}

7
actions/detail.go
View File

@ -6,6 +6,7 @@ import (
"github.com/gin-gonic/gin"
"github/fthvgb1/wp-go/actions/common"
"github/fthvgb1/wp-go/helper"
"github/fthvgb1/wp-go/logs"
"github/fthvgb1/wp-go/models"
"github/fthvgb1/wp-go/plugins"
"math/rand"
@ -55,7 +56,7 @@ func Detail(c *gin.Context) {
}
}
ID := uint64(Id)
post, err := common.GetPostById(c, ID, ID)
post, err := common.GetPostAndCache(c, ID, ID)
if post.Id == 0 || err != nil {
return
}
@ -71,8 +72,10 @@ func Detail(c *gin.Context) {
}
plugins.ApplyPlugin(plugins.NewPostPlugin(c, plugins.Detail), &post)
comments, err := common.PostComments(c, post.Id)
logs.ErrPrintln(err, "get post comment", post.Id)
commentss := treeComments(comments)
prev, next, err := common.GetContextPost(post.Id, post.PostDate)
prev, next, err := common.GetContextPost(c, post.Id, post.PostDate)
logs.ErrPrintln(err, "get pre and next post", post.Id, post.PostDate)
h["title"] = fmt.Sprintf("%s-%s", post.PostTitle, models.Options["blogname"])
h["post"] = post
h["showComment"] = showComment

14
actions/index.go
View File

@ -181,23 +181,23 @@ func Index(c *gin.Context) {
if len(postIds) < 1 && h.category != "" {
h.titleL = "未找到页面"
}
err = common.QueryAndSetPostCache(postIds)
err = common.SetPostCache(postIds)
if err != nil {
return
}
pw := h.session.Get("post_password")
plug := plugins.NewPostPlugin(c, h.scene)
for i, v := range postIds {
post, _ := common.PostsCache.Load(v.Id)
pp := post.(*models.WpPosts)
px := *pp
postIds[i] = px
post := common.GetPost(v.Id)
postIds[i] = post
common.PasswordProjectTitle(&postIds[i])
if px.PostPassword != "" && pw != px.PostPassword {
if post.PostPassword != "" && pw != post.PostPassword {
common.PasswdProjectContent(&postIds[i])
} else {
plugins.ApplyPlugin(plug, &postIds[i])
}
}
for i, post := range recent {
if post.PostPassword != "" && pw != post.PostPassword {
common.PasswdProjectContent(&recent[i])
}

14
cache/map.go vendored
View File

@ -56,6 +56,20 @@ func (m *MapCache[K, V]) Set(k K, v V) {
m.set(k, v)
}
func (m *MapCache[K, V]) SetByBatchFn(params ...any) error {
m.mutex.Lock()
defer m.mutex.Unlock()
r, err := m.setBatchCacheFn(params...)
if err != nil {
return err
}
for k, v := range r {
m.set(k, v)
}
return nil
}
func (m *MapCache[K, V]) set(k K, v V) {
data, ok := m.data[k]
t := time.Now()

26
logs/log.go Normal file
View File

@ -0,0 +1,26 @@
package logs
import (
"log"
"strings"
)
func ErrPrintln(err error, desc string, args ...any) {
s := strings.Builder{}
tmp := "%s err:[%s]"
if desc == "" {
tmp = "%s%s"
}
s.WriteString(tmp)
argss := []any{desc, err}
if len(args) > 0 {
s.WriteString(" args:")
for _, arg := range args {
s.WriteString("%v ")
argss = append(argss, arg)
}
}
if err != nil {
log.Printf(s.String(), argss...)
}
}