render_data.go

package echo

import (
	"database/sql"
	"html/template"
	"time"

	"github.com/admpub/humanize"
	"github.com/admpub/timeago"
	"github.com/webx-top/com"
	"github.com/webx-top/echo/engine"
	"github.com/webx-top/echo/middleware/tplfunc"
	"github.com/webx-top/echo/param"
)

type FormatRender func(ctx Context, data any, code ...int) error
type DataWrapper func(Context, any) any

func DefaultRenderDataWrapper(ctx Context, data any) any {
	return NewRenderData(ctx, data)
}

func NewRenderData(ctx Context, data any) *RenderData {
	if v, ok := data.(*RenderData); ok {
		return v
	}
	return &RenderData{
		ctx:    ctx,
		now:    com.NewTime(time.Now()),
		Func:   ctx.Funcs(),
		Data:   data,
		Stored: param.MapReadonly(ctx.Stored()),
	}
}

type RenderData struct {
	ctx        Context
	now        *com.Time
	themeColor sql.NullString
	Func       template.FuncMap
	Data       any
	Stored     param.MapReadonly
}

func (r *RenderData) Now() *com.Time {
	return r.now
}

func (r *RenderData) UnixTime() int64 {
	return r.now.Unix()
}

// RawT 文本译文原始功能
func (r *RenderData) RawT(format string, args ...any) string {
	return r.ctx.T(format, args...)
}

// T 文本译文
// 可以重写 T 函数，重写的 T 函数功能应该是 RawT + ExtT 的组合效果
func (r *RenderData) T(format string, args ...any) string {
	return r.ctx.T(format, args...)
}

// ExtT 获取到文本译文后的附加功能
func (r *RenderData) ExtT(v string, _ ...any) string {
	return v
}

func (r *RenderData) Lang() LangCode {
	return r.ctx.Lang()
}

func (r *RenderData) ThemeColor() string {
	if !r.themeColor.Valid {
		r.themeColor.Valid = true
		if v, ok := r.ctx.Internal().Get(`ThemeColor`).(string); ok {
			r.themeColor.String = v
		} else {
			r.themeColor.String = r.ctx.Cookie().Get(`ThemeColor`)
		}
		if len(r.themeColor.String) > 0 && !com.IsAlphaNumericUnderscoreHyphen(r.themeColor.String) {
			r.themeColor.String = ``
		}
	}
	return r.themeColor.String
}

func (r *RenderData) Get(key string, defaults ...any) any {
	return r.ctx.Get(key, defaults...)
}

func (r *RenderData) Set(key string, value any) string {
	r.ctx.Set(key, value)
	return ``
}

func (r *RenderData) SetMore(keyValue ...any) string {
	r.ctx.SetMore(keyValue...)
	return ``
}

func (r *RenderData) SetMapItem(key string, mapKey string, mapValue any, mapKeyValue ...any) string {
	switch v := r.ctx.Get(key).(type) {
	case param.Store:
		v.Set(mapKey, mapValue)
		v.SetMore(mapKeyValue...)
	case map[string]any:
		v[mapKey] = mapKeyValue
		param.SetMapItems(v, mapKeyValue...)
	default:
		m := param.Store{}
		r.ctx.Set(key, m)
		m.Set(mapKey, mapValue)
		m.SetMore(mapKeyValue...)
	}
	return ``
}

func (r *RenderData) Incr(key string, n any, defaults ...any) int64 {
	return r.ctx.Incr(key, n, defaults...)
}

func (r *RenderData) Decr(key string, n any, defaults ...any) int64 {
	return r.ctx.Decr(key, n, defaults...)
}

func (r *RenderData) Cookie() Cookier {
	return r.ctx.Cookie()
}

func (r *RenderData) Session() Sessioner {
	return r.ctx.Session()
}

func (r *RenderData) Form(key string, defaults ...string) string {
	return r.ctx.Form(key, defaults...)
}

func (r *RenderData) Formx(key string, defaults ...string) param.String {
	return r.ctx.Formx(key, defaults...)
}

func (r *RenderData) Query(key string, defaults ...string) string {
	return r.ctx.Query(key, defaults...)
}

func (r *RenderData) Queryx(key string, defaults ...string) param.String {
	return r.ctx.Queryx(key, defaults...)
}

func (r *RenderData) FormValues(key string) []string {
	return r.ctx.FormValues(key)
}

func (r *RenderData) FormxValues(key string) param.StringSlice {
	return r.ctx.FormxValues(key)
}

func (r *RenderData) QueryValues(key string) []string {
	return r.ctx.QueryValues(key)
}

func (r *RenderData) QueryxValues(key string) param.StringSlice {
	return r.ctx.QueryxValues(key)
}

func (r *RenderData) Param(key string, defaults ...string) string {
	return r.ctx.Param(key, defaults...)
}

func (r *RenderData) Paramx(key string, defaults ...string) param.String {
	return r.ctx.Paramx(key, defaults...)
}

func (r *RenderData) URL() engine.URL {
	return r.ctx.Request().URL()
}

func (r *RenderData) URI() string {
	return r.ctx.Request().URI()
}

func (r *RenderData) Site() string {
	return r.ctx.Site()
}

func (r *RenderData) SiteRoot() string {
	return r.ctx.SiteRoot()
}

func (r *RenderData) LangURI(lang string) string {
	return r.ctx.LangURI(lang)
}

func (r *RenderData) SiteURI() string {
	return r.SiteRoot() + r.URI()
}

func (r *RenderData) FullURL(myURL string) string {
	return com.FullURL(r.Site(), myURL)
}

func (r *RenderData) Referer() string {
	return r.ctx.Referer()
}

func (r *RenderData) Header() engine.Header {
	return r.ctx.Request().Header()
}

func (r *RenderData) Flash(keys ...string) any {
	return r.ctx.Flash(keys...)
}

func (r *RenderData) HasAnyRequest() bool {
	return r.ctx.HasAnyRequest()
}

func (r *RenderData) DurationFormat(t any, args ...string) *com.Durafmt {
	return tplfunc.DurationFormat(r.Lang().String(), t, args...)
}

func (r *RenderData) TsHumanize(startTime any, endTime ...any) string {
	humanizer, err := humanize.New(r.Lang().String())
	if err != nil {
		return err.Error()
	}
	var (
		startDate = tplfunc.ToTime(startTime)
		endDate   time.Time
	)
	if len(endTime) > 0 {
		endDate = tplfunc.ToTime(endTime[0])
	}
	if endDate.IsZero() {
		endDate = time.Now().Local()
	}
	return humanizer.TimeDiff(endDate, startDate, 0)
}

func (r *RenderData) CaptchaForm(args ...any) template.HTML {
	return tplfunc.CaptchaFormWithURLPrefix(r.ctx.Echo().Prefix(), args...)
}

func (r *RenderData) MakeURL(h any, args ...any) string {
	return r.ctx.Echo().URL(h, args...)
}

func (r *RenderData) Ext() string {
	return r.ctx.DefaultExtension()
}

func (r *RenderData) Fetch(tmpl string, data any) template.HTML {
	b, e := r.ctx.Fetch(tmpl, data)
	if e != nil {
		return template.HTML(e.Error())
	}
	return template.HTML(string(b))
}

func (r *RenderData) TimeAgo(v any, options ...string) string {
	if datetime, ok := v.(string); ok {
		return timeago.Take(datetime, r.Lang().Normalize())
	}
	var option string
	if len(options) > 0 {
		option = options[0]
	}
	return timeago.Timestamp(param.AsInt64(v), r.Lang().Normalize(), option)
}

func (r *RenderData) RootPrefix() string {
	return r.ctx.Echo().Prefix()
}

func (r *RenderData) UploadURL(subdir string, values ...any) string {
	return r.ctx.Echo().UploadURL(r.ctx, subdir, values...)
}

func (r *RenderData) Prefix() string {
	return r.ctx.Route().Prefix
}

func (r *RenderData) Path() string {
	return r.ctx.Path()
}

func (r *RenderData) Queries() map[string][]string {
	return r.ctx.Queries()
}

func (r *RenderData) Domain() string {
	return r.ctx.Domain()
}

func (r *RenderData) Port() int {
	return r.ctx.Port()
}

func (r *RenderData) Scheme() string {
	return r.ctx.Scheme()
}

func (r *RenderData) RequestURI() string {
	return r.ctx.RequestURI()
}

func (r *RenderData) FullRequestURI() string {
	return r.ctx.FullRequestURI()
}

func (r *RenderData) GetNextURL(varNames ...string) string {
	return GetNextURL(r.ctx, varNames...)
}

func (r *RenderData) ReturnToCurrentURL(varNames ...string) string {
	return ReturnToCurrentURL(r.ctx, varNames...)
}

func (r *RenderData) WithNextURL(urlStr string, varNames ...string) string {
	return WithNextURL(r.ctx, urlStr, varNames...)
}

func (r *RenderData) GetOtherURL(urlStr string, next string) string {
	return GetOtherURL(r.ctx, next)
}

//  URLGenerator

func (r *RenderData) RelativeURL(uri string) string {
	return r.ctx.RelativeURL(uri)
}

func (r *RenderData) URLFor(uri string, relative ...bool) string {
	return r.ctx.URLFor(uri, relative...)
}

func (r *RenderData) URLByName(name string, args ...any) string {
	return r.ctx.URLByName(name, args...)
}

func (r *RenderData) RelativeURLByName(name string, args ...any) string {
	return r.ctx.RelativeURLByName(name, args...)
}

// Functions dependent on Context

func (r *RenderData) IsHidden(a IsHiddenContext) bool {
	if a == nil {
		return true
	}
	return a.IsHidden(r.ctx)
}

func (r *RenderData) IsValid(a IsValidContext) bool {
	if a == nil {
		return false
	}
	return a.IsValid(r.ctx)
}

func (r *RenderData) Render(a RenderContext) template.HTML {
	if a == nil {
		return template.HTML(``)
	}
	return a.Render(r.ctx)
}

func (r *RenderData) RenderWithData(a RenderContextWithData, data any) template.HTML {
	if a == nil {
		return template.HTML(``)
	}
	if data == nil {
		data = r
	}
	return a.RenderWithData(r.ctx, data)
}

type (
	IsHiddenContext interface {
		IsHidden(Context) bool
	}
	IsValidContext interface {
		IsValid(Context) bool
	}
	RenderContext interface {
		Render(Context) template.HTML
	}
	RenderContextWithData interface {
		RenderWithData(Context, any) template.HTML
	}
)