优化完善

app/pkg/dao/comments.go

@@ -34,7 +34,7 @@ func PostComments(args ...any) ([]uint64, error) {
 	r, err := model.Finds[models.Comments](ctx, model.Conditions(
 		model.Where(model.SqlBuilder{
 			{"comment_approved", "1"},
-			{"comment_post_ID", "=", number.ToString(postId), "int"},
+			{"comment_post_ID", "=", number.IntToString(postId), "int"},
 		}),
 		model.Fields("comment_ID"),
 		model.Order(model.SqlBuilder{

app/theme/wp/calclass.go

@@ -50,20 +50,20 @@ func (h *Handle) BodyClass() string {
 		if cate.Slug[0] != '%' {
 			class = append(class, str.Join("category-", cate.Slug))
 		}
-		class = append(class, str.Join("category-", number.ToString(cate.Terms.TermId)))
+		class = append(class, str.Join("category-", number.IntToString(cate.Terms.TermId)))
 
 	case constraints.Author:
 		class = append(class, "archive", "author")
 		author := h.Index.Param.Author
 		user, _ := cache.GetUserByName(h.C, author)
-		class = append(class, str.Join("author-", number.ToString(user.Id)))
+		class = append(class, str.Join("author-", number.IntToString(user.Id)))
 		if user.UserLogin[0] != '%' {
 			class = append(class, str.Join("author-", user.UserLogin))
 		}
 
 	case constraints.Detail:
 		class = append(class, "post-template-default", "single", "single-post")
-		class = append(class, str.Join("postid-", number.ToString(h.Detail.Post.Id)))
+		class = append(class, str.Join("postid-", number.IntToString(h.Detail.Post.Id)))
 		if len(h.themeMods.ThemeSupport.PostFormats) > 0 {
 			class = append(class, "single-format-standard")
 		}

model/query.go

@@ -48,7 +48,7 @@ func pagination[T Model](db dbQuery, ctx context.Context, q *QueryCondition, pag
 			err = er
 			return
 		}
-		qx.From = str.Join("( ", sq, " ) ", "table", number.ToString(rand.Int()))
+		qx.From = str.Join("( ", sq, " ) ", "table", number.IntToString(rand.Int()))
 		qx = QueryCondition{
 			From:   qx.From,
 			In:     qx.In,

model/querycondition.go

@@ -36,7 +36,7 @@ func finds[T Model](db dbQuery, ctx context.Context, q *QueryCondition) (r []T,
 		err = db.Select(ctx, &r, sq, args...)
 		return
 	}
-	err = parseRelation(true, db, ctx, &r, q)
+	err = ParseRelation(true, db, ctx, &r, q)
 	return
 }
 
@@ -317,14 +317,14 @@ func gets[T Model](db dbQuery, ctx context.Context, q *QueryCondition) (r T, err
 		err = db.Get(ctx, &r, s, args...)
 		return
 	}
-	err = parseRelation(false, db, ctx, &r, q)
+	err = ParseRelation(false, db, ctx, &r, q)
 	return
 }
 
-func parseRelation(isMultiple bool, db dbQuery, ctx context.Context, r any, q *QueryCondition) (err error) {
+func ParseRelation(isMultiple bool, db dbQuery, ctx context.Context, r any, q *QueryCondition) (err error) {
-	fn, fns := Relation(isMultiple, db, ctx, r, q)
+	before, after := Relation(isMultiple, db, ctx, r, q)
-	for _, f := range fn {
+	for _, fn := range before {
-		f()
+		fn()
 	}
 	s, args, err := BuildQuerySql(q)
 	if err != nil {
@@ -339,8 +339,8 @@ func parseRelation(isMultiple bool, db dbQuery, ctx context.Context, r any, q *Q
 	if err != nil {
 		return
 	}
-	for _, f := range fns {
+	for _, fn := range after {
-		err = f()
+		err = fn()
 		if err != nil {
 			return
 		}

model/relation.go

@@ -25,13 +25,13 @@ type Relationship struct {
 }
 
 func Relation(isMultiple bool, db dbQuery, ctx context.Context, r any, q *QueryCondition) ([]func(), []func() error) {
-	var fn []func()
+	var beforeFn []func()
-	var fns []func() error
+	var afterFn []func() error
 	for _, f := range q.RelationFn {
-		getVal, isJoin, qq, ff := f()
+		getVal, isJoin, qq, relationship := f()
-		idFn, assignment, rr, rrs, ship := ff()
+		idFn, assignmentFn, rr, rrs, ship := relationship()
 		if isJoin {
-			fn = append(fn, func() {
+			beforeFn = append(beforeFn, func() {
 				tables := strings.Split(ship.Table, " ")
 				from := strings.Split(q.From, " ")
 				on := ""
@@ -46,13 +46,12 @@ func Relation(isMultiple bool, db dbQuery, ctx context.Context, r any, q *QueryC
 		if !getVal {
 			continue
 		}
-		fns = append(fns, func() error {
+		afterFn = append(afterFn, func() error {
 			ids := idFn(r)
 			if len(ids) < 1 {
 				return nil
 			}
 			var err error
-			{
 			if qq == nil {
 				qq = &QueryCondition{
 					Fields: "*",
@@ -73,17 +72,19 @@ func Relation(isMultiple bool, db dbQuery, ctx context.Context, r any, q *QueryC
 			if qq.From == "" {
 				qq.From = ship.Table
 			}
-			}
+			err = ParseRelation(isMultiple || ship.RelationType == "hasMany", db, ctx, helper.Or(isMultiple, rrs, rr), qq)
-			err = parseRelation(isMultiple || ship.RelationType == "hasMany", db, ctx, helper.Or(isMultiple, rrs, rr), qq)
+			if err != nil {
-			if err != nil && err != sql.ErrNoRows {
+				if err == sql.ErrNoRows {
+					err = nil
+				} else {
 					return err
 				}
-			assignment(r, helper.Or(isMultiple, rrs, rr))
+			}
-
+			assignmentFn(r, helper.Or(isMultiple, rrs, rr))
 			return err
 		})
 	}
-	return fn, fns
+	return beforeFn, afterFn
 }
 
 func GetWithID[T, V any](fn func(*T) V) func(any) []any {
@@ -98,47 +99,52 @@ func GetWithID[T, V any](fn func(*T) V) func(any) []any {
 	}
 }
 
-func SetHasOne[T, V any, K comparable](fn func(*T, *V), idFn func(*T) K, iddFn func(*V) K) func(any, any) {
+// SetHasOne mIdFn is main , pIdFn is part
-	return func(m, v any) {
+//
+// eg: post has a user. mIdFn is post's userId, iddFn is user's id
+func SetHasOne[T, V any, K comparable](assignmentFn func(*T, *V), mIdFn func(*T) K, pIdFn func(*V) K) func(any, any) {
+	return func(m, p any) {
 		one, ok := m.(*T)
 		if ok {
-			fn(one, v.(*V))
+			assignmentFn(one, p.(*V))
 			return
 		}
-		r := m.(*[]T)
+		mSlice := m.(*[]T)
-		vv := v.(*[]V)
+		pSLice := p.(*[]V)
-		mm := slice.SimpleToMap(*vv, func(v V) K {
+		mm := slice.SimpleToMap(*pSLice, func(v V) K {
-			return iddFn(&v)
+			return pIdFn(&v)
 		})
-		for i := 0; i < len(*r); i++ {
+		for i := 0; i < len(*mSlice); i++ {
-			val := &(*r)[i]
+			m := &(*mSlice)[i]
-			id := idFn(val)
+			id := mIdFn(m)
-			v, ok := mm[id]
+			p, ok := mm[id]
 			if ok {
-				fn(val, &v)
+				assignmentFn(m, &p)
 			}
 		}
 	}
 }
 
-func SetHasMany[T, V any, K comparable](fn func(*T, *[]V), idFn func(*T) K, iddFn func(*V) K) func(any, any) {
+// SetHasMany
-	return func(m, v any) {
+// eg: post has many comments,pIdFn is comment's postId, mIdFn is post's id
+func SetHasMany[T, V any, K comparable](assignmentFn func(*T, *[]V), pIdFn func(*T) K, mIdFn func(*V) K) func(any, any) {
+	return func(m, p any) {
 		one, ok := m.(*T)
 		if ok {
-			fn(one, v.(*[]V))
+			assignmentFn(one, p.(*[]V))
 			return
 		}
 		r := m.(*[]T)
-		vv := v.(*[]V)
+		vv := p.(*[]V)
 		mm := slice.GroupBy(*vv, func(t V) (K, V) {
-			return iddFn(&t), t
+			return mIdFn(&t), t
 		})
 		for i := 0; i < len(*r); i++ {
-			val := &(*r)[i]
+			m := &(*r)[i]
-			id := idFn(val)
+			id := pIdFn(m)
-			v, ok := mm[id]
+			p, ok := mm[id]
 			if ok {
-				fn(val, &v)
+				assignmentFn(m, &p)
 			}
 		}
 	}