forgejo/modules/templates/helper.go

449 lines
11 KiB
Go
Raw Normal View History

2014-04-10 20:20:58 +02:00
// Copyright 2014 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package templates
2014-04-10 20:20:58 +02:00
import (
"bytes"
2014-04-10 20:20:58 +02:00
"container/list"
"encoding/json"
"errors"
2014-04-10 20:20:58 +02:00
"fmt"
"html"
2014-04-10 20:20:58 +02:00
"html/template"
"mime"
"net/url"
"path/filepath"
2014-05-22 03:37:13 +02:00
"runtime"
2014-04-10 20:20:58 +02:00
"strings"
"time"
2014-05-26 02:11:25 +02:00
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/markup"
"code.gitea.io/gitea/modules/setting"
2017-11-22 08:09:48 +01:00
"golang.org/x/net/html/charset"
"golang.org/x/text/transform"
"gopkg.in/editorconfig/editorconfig-core-go.v1"
2014-04-10 20:20:58 +02:00
)
2016-11-25 07:23:48 +01:00
// NewFuncMap returns functions for injecting to templates
2016-03-06 22:40:04 +01:00
func NewFuncMap() []template.FuncMap {
return []template.FuncMap{map[string]interface{}{
"GoVer": func() string {
return strings.Title(runtime.Version())
},
"UseHTTPS": func() bool {
return strings.HasPrefix(setting.AppURL, "https")
2016-03-06 22:40:04 +01:00
},
"AppName": func() string {
return setting.AppName
},
"AppSubUrl": func() string {
return setting.AppSubURL
2016-03-06 22:40:04 +01:00
},
"AppUrl": func() string {
return setting.AppURL
2016-03-06 22:40:04 +01:00
},
"AppVer": func() string {
return setting.AppVer
},
"AppBuiltWith": func() string {
return setting.AppBuiltWith
},
2016-03-06 22:40:04 +01:00
"AppDomain": func() string {
return setting.Domain
},
"DisableGravatar": func() bool {
return setting.DisableGravatar
},
"ShowFooterTemplateLoadTime": func() bool {
return setting.ShowFooterTemplateLoadTime
},
2016-03-06 22:40:04 +01:00
"LoadTimes": func(startTime time.Time) string {
return fmt.Sprint(time.Since(startTime).Nanoseconds()/1e6) + "ms"
},
"AvatarLink": base.AvatarLink,
"Safe": Safe,
"SafeJS": SafeJS,
"Str2html": Str2html,
"TimeSince": base.TimeSince,
"TimeSinceUnix": base.TimeSinceUnix,
"RawTimeSince": base.RawTimeSince,
"FileSize": base.FileSize,
"Subtract": base.Subtract,
2016-03-06 22:40:04 +01:00
"Add": func(a, b int) int {
return a + b
},
"ActionIcon": ActionIcon,
"DateFmtLong": func(t time.Time) string {
return t.Format(time.RFC1123Z)
},
"DateFmtShort": func(t time.Time) string {
return t.Format("Jan 02, 2006")
},
"SizeFmt": func(s int64) string {
return base.FileSize(s)
},
2016-03-06 22:40:04 +01:00
"List": List,
"SubStr": func(str string, start, length int) string {
if len(str) == 0 {
return ""
}
end := start + length
if length == -1 {
end = len(str)
}
if len(str) < end {
return str
}
return str[start:end]
},
2016-08-30 14:07:50 +02:00
"EllipsisString": base.EllipsisString,
2016-03-06 22:40:04 +01:00
"DiffTypeToStr": DiffTypeToStr,
"DiffLineTypeToStr": DiffLineTypeToStr,
"Sha1": Sha1,
"ShortSha": base.ShortSha,
"MD5": base.EncodeMD5,
"ActionContent2Commits": ActionContent2Commits,
"PathEscape": url.PathEscape,
2016-03-06 22:40:04 +01:00
"EscapePound": func(str string) string {
return strings.NewReplacer("%", "%25", "#", "%23", " ", "%20", "?", "%3F").Replace(str)
2016-03-06 22:40:04 +01:00
},
"RenderCommitMessage": RenderCommitMessage,
"RenderCommitMessageLink": RenderCommitMessageLink,
"RenderCommitBody": RenderCommitBody,
"IsMultilineCommitMessage": IsMultilineCommitMessage,
2016-03-06 22:40:04 +01:00
"ThemeColorMetaTag": func() string {
2016-07-23 18:23:54 +02:00
return setting.UI.ThemeColorMetaTag
2016-03-06 22:40:04 +01:00
},
"MetaAuthor": func() string {
return setting.UI.Meta.Author
},
"MetaDescription": func() string {
return setting.UI.Meta.Description
},
"MetaKeywords": func() string {
return setting.UI.Meta.Keywords
},
"FilenameIsImage": func(filename string) bool {
mimeType := mime.TypeByExtension(filepath.Ext(filename))
return strings.HasPrefix(mimeType, "image/")
},
"TabSizeClass": func(ec *editorconfig.Editorconfig, filename string) string {
if ec != nil {
def := ec.GetDefinitionForFilename(filename)
if def.TabWidth > 0 {
return fmt.Sprintf("tab-size-%d", def.TabWidth)
}
}
return "tab-size-8"
},
2016-12-28 17:35:52 +01:00
"SubJumpablePath": func(str string) []string {
var path []string
index := strings.LastIndex(str, "/")
if index != -1 && index != len(str) {
path = append(path, str[0:index+1])
path = append(path, str[index+1:])
2016-12-28 17:35:52 +01:00
} else {
path = append(path, str)
}
return path
},
"JsonPrettyPrint": func(in string) string {
var out bytes.Buffer
err := json.Indent(&out, []byte(in), "", " ")
if err != nil {
return ""
}
return out.String()
},
"DisableGitHooks": func() bool {
return setting.DisableGitHooks
},
"TrN": TrN,
"Dict": func(values ...interface{}) (map[string]interface{}, error) {
if len(values)%2 != 0 {
return nil, errors.New("invalid dict call")
}
dict := make(map[string]interface{}, len(values)/2)
for i := 0; i < len(values); i += 2 {
key, ok := values[i].(string)
if !ok {
return nil, errors.New("dict keys must be strings")
}
dict[key] = values[i+1]
}
return dict, nil
},
Shows total tracked time in issue and milestone list (#3341) * Show total tracked time in issue and milestone list Show total tracked time at issue page Signed-off-by: Jonas Franz <info@jonasfranz.software> * Optimizing TotalTimes by using SumInt Signed-off-by: Jonas Franz <info@jonasfranz.software> * Fixing wrong total times for milestones caused by a missing JOIN Adding unit tests for total times Signed-off-by: Jonas Franz <info@jonasfranz.software> * Logging error instead of ignoring it Signed-off-by: Jonas Franz <info@jonasfranz.software> * Correcting spelling mistakes Signed-off-by: Jonas Franz <info@jonasfranz.software> * Change error message to a short version Signed-off-by: Jonas Franz <info@jonasfranz.software> * Add error handling to TotalTimes Add variable for totalTimes Signed-off-by: Jonas Franz <info@jonasfranz.de> * Introduce TotalTrackedTimes as variable of issue Load TotalTrackedTimes by loading attributes of IssueList Load TotalTrackedTimes by loading attributes of single issue Add Sec2Time as helper to use it in templates Signed-off-by: Jonas Franz <info@jonasfranz.software> * Fixed test + gofmt Signed-off-by: Jonas Franz <info@jonasfranz.software> * Load TotalTrackedTimes via MilestoneList instead of single requests Signed-off-by: Jonas Franz <info@jonasfranz.software> * Add documentation for MilestoneList Signed-off-by: Jonas Franz <info@jonasfranz.software> * Add documentation for MilestoneList Signed-off-by: Jonas Franz <info@jonasfranz.software> * Fix test Signed-off-by: Jonas Franz <info@jonasfranz.software> * Change comment from SQL query to description Signed-off-by: Jonas Franz <info@jonasfranz.software> * Fix unit test by using int64 instead of int Signed-off-by: Jonas Franz <info@jonasfranz.software> * Fix unit test by using int64 instead of int Signed-off-by: Jonas Franz <info@jonasfranz.software> * Check if timetracker is enabled Signed-off-by: Jonas Franz <info@jonasfranz.software> * Fix test by enabling timetracking Signed-off-by: Jonas Franz <info@jonasfranz.de>
2018-04-29 07:58:47 +02:00
"Printf": fmt.Sprintf,
"Escape": Escape,
"Sec2Time": models.SecToTime,
2016-03-06 22:40:04 +01:00
}}
2015-11-14 04:45:33 +01:00
}
2016-11-25 07:23:48 +01:00
// Safe render raw as HTML
2015-08-08 11:10:34 +02:00
func Safe(raw string) template.HTML {
return template.HTML(raw)
}
// SafeJS renders raw as JS
func SafeJS(raw string) template.JS {
return template.JS(raw)
}
2016-11-25 07:23:48 +01:00
// Str2html render Markdown text to HTML
2014-04-10 20:20:58 +02:00
func Str2html(raw string) template.HTML {
return template.HTML(markup.Sanitize(raw))
2014-04-10 20:20:58 +02:00
}
// Escape escapes a HTML string
func Escape(raw string) string {
return html.EscapeString(raw)
}
2016-11-25 07:23:48 +01:00
// List traversings the list
2014-04-10 20:20:58 +02:00
func List(l *list.List) chan interface{} {
e := l.Front()
c := make(chan interface{})
go func() {
for e != nil {
c <- e.Value
e = e.Next()
}
close(c)
}()
return c
}
2016-11-25 07:23:48 +01:00
// Sha1 returns sha1 sum of string
2015-02-18 22:52:22 +01:00
func Sha1(str string) string {
2015-11-13 23:10:25 +01:00
return base.EncodeSha1(str)
2014-12-09 08:18:25 +01:00
}
2016-11-25 07:23:48 +01:00
// ToUTF8WithErr converts content to UTF8 encoding
func ToUTF8WithErr(content []byte) (string, error) {
charsetLabel, err := base.DetectEncoding(content)
if err != nil {
2016-11-25 07:23:48 +01:00
return "", err
} else if charsetLabel == "UTF-8" {
2016-11-25 07:23:48 +01:00
return string(content), nil
}
encoding, _ := charset.Lookup(charsetLabel)
if encoding == nil {
2016-11-25 07:23:48 +01:00
return string(content), fmt.Errorf("Unknown encoding: %s", charsetLabel)
}
// If there is an error, we concatenate the nicely decoded part and the
// original left over. This way we won't loose data.
result, n, err := transform.String(encoding.NewDecoder(), string(content))
if err != nil {
result = result + string(content[n:])
}
2016-11-25 07:23:48 +01:00
return result, err
}
2016-11-25 07:23:48 +01:00
// ToUTF8 converts content to UTF8 encoding and ignore error
2016-08-09 21:56:00 +02:00
func ToUTF8(content string) string {
2016-11-25 07:23:48 +01:00
res, _ := ToUTF8WithErr([]byte(content))
return res
}
2016-11-25 07:23:48 +01:00
// ReplaceLeft replaces all prefixes 'old' in 's' with 'new'.
func ReplaceLeft(s, old, new string) string {
2016-11-25 07:23:48 +01:00
oldLen, newLen, i, n := len(old), len(new), 0, 0
for ; i < len(s) && strings.HasPrefix(s[i:], old); n++ {
i += oldLen
}
// simple optimization
if n == 0 {
return s
}
// allocating space for the new string
2016-11-25 07:23:48 +01:00
curLen := n*newLen + len(s[i:])
replacement := make([]byte, curLen, curLen)
j := 0
2016-11-25 07:23:48 +01:00
for ; j < n*newLen; j += newLen {
copy(replacement[j:j+newLen], new)
}
copy(replacement[j:], s[i:])
return string(replacement)
}
// RenderCommitMessage renders commit message with XSS-safe and special links.
func RenderCommitMessage(msg, urlPrefix string, metas map[string]string) template.HTML {
return RenderCommitMessageLink(msg, urlPrefix, "", metas)
}
// RenderCommitMessageLink renders commit message as a XXS-safe link to the provided
// default url, handling for special links.
func RenderCommitMessageLink(msg, urlPrefix, urlDefault string, metas map[string]string) template.HTML {
cleanMsg := template.HTMLEscapeString(msg)
// we can safely assume that it will not return any error, since there
// shouldn't be any special HTML.
fullMessage, err := markup.RenderCommitMessage([]byte(cleanMsg), urlPrefix, urlDefault, metas)
if err != nil {
log.Error(3, "RenderCommitMessage: %v", err)
return ""
}
msgLines := strings.Split(strings.TrimSpace(string(fullMessage)), "\n")
if len(msgLines) == 0 {
return template.HTML("")
}
return template.HTML(msgLines[0])
}
// RenderCommitBody extracts the body of a commit message without its title.
func RenderCommitBody(msg, urlPrefix string, metas map[string]string) template.HTML {
cleanMsg := template.HTMLEscapeString(msg)
fullMessage, err := markup.RenderCommitMessage([]byte(cleanMsg), urlPrefix, "", metas)
if err != nil {
log.Error(3, "RenderCommitMessage: %v", err)
return ""
}
body := strings.Split(strings.TrimSpace(string(fullMessage)), "\n")
if len(body) == 0 {
return template.HTML("")
}
return template.HTML(strings.Join(body[1:], "\n"))
}
// IsMultilineCommitMessage checks to see if a commit message contains multiple lines.
func IsMultilineCommitMessage(msg string) bool {
return strings.Count(strings.TrimSpace(msg), "\n") > 1
}
2016-11-25 07:23:48 +01:00
// Actioner describes an action
2014-04-10 20:20:58 +02:00
type Actioner interface {
GetOpType() models.ActionType
2014-04-10 20:20:58 +02:00
GetActUserName() string
2014-05-09 08:42:50 +02:00
GetRepoUserName() string
2014-04-10 20:20:58 +02:00
GetRepoName() string
2015-09-01 15:29:52 +02:00
GetRepoPath() string
GetRepoLink() string
2014-04-10 20:20:58 +02:00
GetBranch() string
GetContent() string
2015-09-01 15:29:52 +02:00
GetCreate() time.Time
GetIssueInfos() []string
2014-04-10 20:20:58 +02:00
}
// ActionIcon accepts an action operation type and returns an icon class name.
func ActionIcon(opType models.ActionType) string {
2014-04-10 20:20:58 +02:00
switch opType {
case models.ActionCreateRepo, models.ActionTransferRepo:
2014-07-26 06:24:27 +02:00
return "repo"
case models.ActionCommitRepo, models.ActionPushTag, models.ActionDeleteTag, models.ActionDeleteBranch:
2014-07-26 06:24:27 +02:00
return "git-commit"
case models.ActionCreateIssue:
2014-07-26 06:24:27 +02:00
return "issue-opened"
case models.ActionCreatePullRequest:
2015-11-16 17:39:48 +01:00
return "git-pull-request"
case models.ActionCommentIssue:
2016-07-16 06:45:13 +02:00
return "comment-discussion"
case models.ActionMergePullRequest:
2015-11-16 17:39:48 +01:00
return "git-merge"
case models.ActionCloseIssue, models.ActionClosePullRequest:
return "issue-closed"
case models.ActionReopenIssue, models.ActionReopenPullRequest:
return "issue-reopened"
2014-04-10 20:20:58 +02:00
default:
return "invalid type"
}
}
2016-11-25 07:23:48 +01:00
// ActionContent2Commits converts action content to push commits
2015-11-13 23:10:25 +01:00
func ActionContent2Commits(act Actioner) *models.PushCommits {
push := models.NewPushCommits()
if err := json.Unmarshal([]byte(act.GetContent()), push); err != nil {
log.Error(4, "json.Unmarshal:\n%s\nERROR: %v", act.GetContent(), err)
2014-07-26 06:24:27 +02:00
}
return push
}
2016-11-25 07:23:48 +01:00
// DiffTypeToStr returns diff type name
2014-04-10 20:20:58 +02:00
func DiffTypeToStr(diffType int) string {
diffTypes := map[int]string{
2015-11-03 15:52:17 +01:00
1: "add", 2: "modify", 3: "del", 4: "rename",
2014-04-10 20:20:58 +02:00
}
return diffTypes[diffType]
}
2016-11-25 07:23:48 +01:00
// DiffLineTypeToStr returns diff line type name
2014-04-10 20:20:58 +02:00
func DiffLineTypeToStr(diffType int) string {
switch diffType {
case 2:
return "add"
case 3:
return "del"
case 4:
return "tag"
}
return "same"
}
// Language specific rules for translating plural texts
var trNLangRules = map[string]func(int64) int{
"en-US": func(cnt int64) int {
if cnt == 1 {
return 0
}
return 1
},
"lv-LV": func(cnt int64) int {
if cnt%10 == 1 && cnt%100 != 11 {
return 0
}
return 1
},
"ru-RU": func(cnt int64) int {
if cnt%10 == 1 && cnt%100 != 11 {
return 0
}
return 1
},
"zh-CN": func(cnt int64) int {
return 0
},
"zh-HK": func(cnt int64) int {
return 0
},
"zh-TW": func(cnt int64) int {
return 0
},
}
// TrN returns key to be used for plural text translation
func TrN(lang string, cnt interface{}, key1, keyN string) string {
var c int64
if t, ok := cnt.(int); ok {
c = int64(t)
} else if t, ok := cnt.(int16); ok {
c = int64(t)
} else if t, ok := cnt.(int32); ok {
c = int64(t)
} else if t, ok := cnt.(int64); ok {
c = t
} else {
return keyN
}
ruleFunc, ok := trNLangRules[lang]
if !ok {
ruleFunc = trNLangRules["en-US"]
}
if ruleFunc(c) == 0 {
return key1
}
return keyN
}