2018-09-29 04:33:54 -04:00
|
|
|
// Copyright 2018 The Gitea Authors. All rights reserved.
|
2014-04-10 14:20:58 -04: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.
|
|
|
|
|
2016-12-06 12:58:31 -05:00
|
|
|
package templates
|
2014-04-10 14:20:58 -04:00
|
|
|
|
|
|
|
import (
|
2017-03-01 19:25:44 -05:00
|
|
|
"bytes"
|
2022-01-19 18:26:57 -05:00
|
|
|
"context"
|
2017-12-03 18:14:26 -05:00
|
|
|
"errors"
|
2014-04-10 14:20:58 -04:00
|
|
|
"fmt"
|
2018-02-27 02:09:18 -05:00
|
|
|
"html"
|
2014-04-10 14:20:58 -04:00
|
|
|
"html/template"
|
2016-08-11 19:16:36 -04:00
|
|
|
"mime"
|
2017-11-28 04:43:51 -05:00
|
|
|
"net/url"
|
2016-08-11 19:16:36 -04:00
|
|
|
"path/filepath"
|
2020-11-08 12:21:54 -05:00
|
|
|
"reflect"
|
2019-11-07 08:34:28 -05:00
|
|
|
"regexp"
|
2014-05-21 21:37:13 -04:00
|
|
|
"runtime"
|
2022-06-08 04:59:16 -04:00
|
|
|
"strconv"
|
2014-04-10 14:20:58 -04:00
|
|
|
"strings"
|
2019-11-07 08:34:28 -05:00
|
|
|
texttmpl "text/template"
|
2014-04-10 14:20:58 -04:00
|
|
|
"time"
|
2019-11-01 00:48:30 -04:00
|
|
|
"unicode"
|
2014-05-25 20:11:25 -04:00
|
|
|
|
2022-08-24 22:31:57 -04:00
|
|
|
activities_model "code.gitea.io/gitea/models/activities"
|
Avatar refactor, move avatar code from `models` to `models.avatars`, remove duplicated code (#17123)
Why this refactor
The goal is to move most files from `models` package to `models.xxx` package. Many models depend on avatar model, so just move this first.
And the existing logic is not clear, there are too many function like `AvatarLink`, `RelAvatarLink`, `SizedRelAvatarLink`, `SizedAvatarLink`, `MakeFinalAvatarURL`, `HashedAvatarLink`, etc. This refactor make everything clear:
* user.AvatarLink()
* user.AvatarLinkWithSize(size)
* avatars.GenerateEmailAvatarFastLink(email, size)
* avatars.GenerateEmailAvatarFinalLink(email, size)
And many duplicated code are deleted in route handler, the handler and the model share the same avatar logic now.
2021-10-05 19:25:46 -04:00
|
|
|
"code.gitea.io/gitea/models/avatars"
|
2022-06-13 05:37:59 -04:00
|
|
|
issues_model "code.gitea.io/gitea/models/issues"
|
2022-03-29 02:29:02 -04:00
|
|
|
"code.gitea.io/gitea/models/organization"
|
2021-12-09 20:27:50 -05:00
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
2022-10-16 19:29:26 -04:00
|
|
|
system_model "code.gitea.io/gitea/models/system"
|
2021-11-24 04:49:20 -05:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2016-11-10 11:24:48 -05:00
|
|
|
"code.gitea.io/gitea/modules/base"
|
2020-04-28 14:05:39 -04:00
|
|
|
"code.gitea.io/gitea/modules/emoji"
|
2021-06-14 13:20:43 -04:00
|
|
|
"code.gitea.io/gitea/modules/git"
|
2022-06-11 09:50:14 -04:00
|
|
|
giturl "code.gitea.io/gitea/modules/git/url"
|
2022-11-08 10:13:58 -05:00
|
|
|
gitea_html "code.gitea.io/gitea/modules/html"
|
2021-07-24 12:03:58 -04:00
|
|
|
"code.gitea.io/gitea/modules/json"
|
2016-11-10 11:24:48 -05:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2017-09-16 13:17:57 -04:00
|
|
|
"code.gitea.io/gitea/modules/markup"
|
2022-03-30 04:42:47 -04:00
|
|
|
"code.gitea.io/gitea/modules/markup/markdown"
|
2020-01-10 04:34:21 -05:00
|
|
|
"code.gitea.io/gitea/modules/repository"
|
2016-11-10 11:24:48 -05:00
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2020-07-12 05:10:56 -04:00
|
|
|
"code.gitea.io/gitea/modules/svg"
|
2019-08-15 10:46:21 -04:00
|
|
|
"code.gitea.io/gitea/modules/timeutil"
|
|
|
|
"code.gitea.io/gitea/modules/util"
|
2019-09-05 22:20:09 -04:00
|
|
|
"code.gitea.io/gitea/services/gitdiff"
|
2017-11-22 02:09:48 -05:00
|
|
|
|
2019-10-15 17:24:16 -04:00
|
|
|
"github.com/editorconfig/editorconfig-core-go/v2"
|
2014-04-10 14:20:58 -04:00
|
|
|
)
|
|
|
|
|
2019-11-07 08:34:28 -05:00
|
|
|
// Used from static.go && dynamic.go
|
|
|
|
var mailSubjectSplit = regexp.MustCompile(`(?m)^-{3,}[\s]*$`)
|
|
|
|
|
2016-11-25 01:23:48 -05:00
|
|
|
// NewFuncMap returns functions for injecting to templates
|
2016-03-06 16:40:04 -05:00
|
|
|
func NewFuncMap() []template.FuncMap {
|
|
|
|
return []template.FuncMap{map[string]interface{}{
|
|
|
|
"GoVer": func() string {
|
2022-05-10 17:55:54 -04:00
|
|
|
return util.ToTitleCase(runtime.Version())
|
2016-03-06 16:40:04 -05:00
|
|
|
},
|
|
|
|
"UseHTTPS": func() bool {
|
2016-11-27 05:14:25 -05:00
|
|
|
return strings.HasPrefix(setting.AppURL, "https")
|
2016-03-06 16:40:04 -05:00
|
|
|
},
|
|
|
|
"AppName": func() string {
|
|
|
|
return setting.AppName
|
|
|
|
},
|
|
|
|
"AppSubUrl": func() string {
|
2016-11-27 05:14:25 -05:00
|
|
|
return setting.AppSubURL
|
2016-03-06 16:40:04 -05:00
|
|
|
},
|
2021-05-08 10:27:25 -04:00
|
|
|
"AssetUrlPrefix": func() string {
|
2021-04-28 08:35:06 -04:00
|
|
|
return setting.StaticURLPrefix + "/assets"
|
2019-10-22 08:11:01 -04:00
|
|
|
},
|
2016-03-06 16:40:04 -05:00
|
|
|
"AppUrl": func() string {
|
2016-11-27 05:14:25 -05:00
|
|
|
return setting.AppURL
|
2016-03-06 16:40:04 -05:00
|
|
|
},
|
|
|
|
"AppVer": func() string {
|
|
|
|
return setting.AppVer
|
|
|
|
},
|
2017-02-27 19:40:02 -05:00
|
|
|
"AppBuiltWith": func() string {
|
2017-02-28 20:45:21 -05:00
|
|
|
return setting.AppBuiltWith
|
2017-02-27 19:40:02 -05:00
|
|
|
},
|
2016-03-06 16:40:04 -05:00
|
|
|
"AppDomain": func() string {
|
|
|
|
return setting.Domain
|
|
|
|
},
|
2022-08-23 08:58:04 -04:00
|
|
|
"AssetVersion": func() string {
|
|
|
|
return setting.AssetVersion
|
|
|
|
},
|
2016-03-06 16:40:04 -05:00
|
|
|
"DisableGravatar": func() bool {
|
2022-11-10 01:43:53 -05:00
|
|
|
return system_model.GetSettingBool(system_model.KeyPictureDisableGravatar)
|
2016-03-06 16:40:04 -05:00
|
|
|
},
|
2019-05-08 04:41:35 -04:00
|
|
|
"DefaultShowFullName": func() bool {
|
|
|
|
return setting.UI.DefaultShowFullName
|
|
|
|
},
|
2016-09-01 01:01:32 -04:00
|
|
|
"ShowFooterTemplateLoadTime": func() bool {
|
|
|
|
return setting.ShowFooterTemplateLoadTime
|
|
|
|
},
|
2016-03-06 16:40:04 -05:00
|
|
|
"LoadTimes": func(startTime time.Time) string {
|
|
|
|
return fmt.Sprint(time.Since(startTime).Nanoseconds()/1e6) + "ms"
|
|
|
|
},
|
2019-12-27 18:43:56 -05:00
|
|
|
"AllowedReactions": func() []string {
|
|
|
|
return setting.UI.Reactions
|
|
|
|
},
|
2021-06-29 10:28:38 -04:00
|
|
|
"CustomEmojis": func() map[string]string {
|
|
|
|
return setting.UI.CustomEmojisMap
|
|
|
|
},
|
2022-06-12 08:08:23 -04:00
|
|
|
"Safe": Safe,
|
|
|
|
"SafeJS": SafeJS,
|
|
|
|
"JSEscape": JSEscape,
|
|
|
|
"Str2html": Str2html,
|
|
|
|
"TimeSince": timeutil.TimeSince,
|
|
|
|
"TimeSinceUnix": timeutil.TimeSinceUnix,
|
|
|
|
"FileSize": base.FileSize,
|
|
|
|
"PrettyNumber": base.PrettyNumber,
|
|
|
|
"JsPrettyNumber": JsPrettyNumber,
|
|
|
|
"Subtract": base.Subtract,
|
|
|
|
"EntryIcon": base.EntryIcon,
|
|
|
|
"MigrationIcon": MigrationIcon,
|
2020-08-06 04:04:08 -04:00
|
|
|
"Add": func(a ...int) int {
|
|
|
|
sum := 0
|
|
|
|
for _, val := range a {
|
|
|
|
sum += val
|
|
|
|
}
|
|
|
|
return sum
|
|
|
|
},
|
|
|
|
"Mul": func(a ...int) int {
|
|
|
|
sum := 1
|
|
|
|
for _, val := range a {
|
|
|
|
sum *= val
|
|
|
|
}
|
|
|
|
return sum
|
2016-03-06 16:40:04 -05:00
|
|
|
},
|
|
|
|
"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")
|
|
|
|
},
|
2020-09-16 00:07:18 -04:00
|
|
|
"CountFmt": base.FormatNumberSI,
|
2016-03-06 16:40:04 -05:00
|
|
|
"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]
|
|
|
|
},
|
2021-11-16 13:18:25 -05:00
|
|
|
"EllipsisString": base.EllipsisString,
|
|
|
|
"DiffTypeToStr": DiffTypeToStr,
|
|
|
|
"DiffLineTypeToStr": DiffLineTypeToStr,
|
|
|
|
"ShortSha": base.ShortSha,
|
|
|
|
"ActionContent2Commits": ActionContent2Commits,
|
|
|
|
"PathEscape": url.PathEscape,
|
2019-09-10 05:03:30 -04:00
|
|
|
"PathEscapeSegments": util.PathEscapeSegments,
|
|
|
|
"URLJoin": util.URLJoin,
|
|
|
|
"RenderCommitMessage": RenderCommitMessage,
|
|
|
|
"RenderCommitMessageLink": RenderCommitMessageLink,
|
|
|
|
"RenderCommitMessageLinkSubject": RenderCommitMessageLinkSubject,
|
|
|
|
"RenderCommitBody": RenderCommitBody,
|
2022-10-15 14:24:41 -04:00
|
|
|
"RenderCodeBlock": RenderCodeBlock,
|
2020-12-03 05:50:47 -05:00
|
|
|
"RenderIssueTitle": RenderIssueTitle,
|
2020-04-28 14:05:39 -04:00
|
|
|
"RenderEmoji": RenderEmoji,
|
|
|
|
"RenderEmojiPlain": emoji.ReplaceAliases,
|
|
|
|
"ReactionToEmoji": ReactionToEmoji,
|
2019-09-10 05:03:30 -04:00
|
|
|
"RenderNote": RenderNote,
|
2022-03-30 04:42:47 -04:00
|
|
|
"RenderMarkdownToHtml": func(input string) template.HTML {
|
|
|
|
output, err := markdown.RenderString(&markup.RenderContext{
|
|
|
|
URLPrefix: setting.AppSubURL,
|
|
|
|
}, input)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("RenderString: %v", err)
|
|
|
|
}
|
|
|
|
return template.HTML(output)
|
|
|
|
},
|
|
|
|
"IsMultilineCommitMessage": IsMultilineCommitMessage,
|
2016-03-06 16:40:04 -05:00
|
|
|
"ThemeColorMetaTag": func() string {
|
2016-07-23 12:23:54 -04:00
|
|
|
return setting.UI.ThemeColorMetaTag
|
2016-03-06 16:40:04 -05:00
|
|
|
},
|
2017-03-31 21:03:01 -04: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
|
|
|
|
},
|
2019-11-21 15:06:23 -05:00
|
|
|
"UseServiceWorker": func() bool {
|
|
|
|
return setting.UI.UseServiceWorker
|
|
|
|
},
|
2021-02-19 18:06:56 -05:00
|
|
|
"EnableTimetracking": func() bool {
|
|
|
|
return setting.Service.EnableTimetracking
|
|
|
|
},
|
2016-08-11 19:16:36 -04:00
|
|
|
"FilenameIsImage": func(filename string) bool {
|
|
|
|
mimeType := mime.TypeByExtension(filepath.Ext(filename))
|
|
|
|
return strings.HasPrefix(mimeType, "image/")
|
|
|
|
},
|
2020-07-02 13:33:13 -04:00
|
|
|
"TabSizeClass": func(ec interface{}, filename string) string {
|
|
|
|
var (
|
|
|
|
value *editorconfig.Editorconfig
|
|
|
|
ok bool
|
|
|
|
)
|
2016-08-11 20:07:09 -04:00
|
|
|
if ec != nil {
|
2020-07-02 13:33:13 -04:00
|
|
|
if value, ok = ec.(*editorconfig.Editorconfig); !ok || value == nil {
|
|
|
|
return "tab-size-8"
|
|
|
|
}
|
|
|
|
def, err := value.GetDefinitionForFilename(filename)
|
2019-10-15 17:24:16 -04:00
|
|
|
if err != nil {
|
|
|
|
log.Error("tab size class: getting definition for filename: %v", err)
|
|
|
|
return "tab-size-8"
|
|
|
|
}
|
2016-08-11 20:07:09 -04:00
|
|
|
if def.TabWidth > 0 {
|
|
|
|
return fmt.Sprintf("tab-size-%d", def.TabWidth)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "tab-size-8"
|
|
|
|
},
|
2016-12-28 11:35:52 -05:00
|
|
|
"SubJumpablePath": func(str string) []string {
|
|
|
|
var path []string
|
|
|
|
index := strings.LastIndex(str, "/")
|
|
|
|
if index != -1 && index != len(str) {
|
2019-05-28 11:45:54 -04:00
|
|
|
path = append(path, str[0:index+1], str[index+1:])
|
2016-12-28 11:35:52 -05:00
|
|
|
} else {
|
|
|
|
path = append(path, str)
|
|
|
|
}
|
|
|
|
return path
|
|
|
|
},
|
2022-01-20 12:46:10 -05:00
|
|
|
"DiffStatsWidth": func(adds, dels int) string {
|
2020-11-15 18:50:06 -05:00
|
|
|
return fmt.Sprintf("%f", float64(adds)/(float64(adds)+float64(dels))*100)
|
|
|
|
},
|
2020-01-20 05:07:30 -05:00
|
|
|
"Json": func(in interface{}) string {
|
2021-07-24 12:03:58 -04:00
|
|
|
out, err := json.Marshal(in)
|
2020-01-20 05:07:30 -05:00
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return string(out)
|
|
|
|
},
|
2017-03-01 19:25:44 -05:00
|
|
|
"JsonPrettyPrint": func(in string) string {
|
|
|
|
var out bytes.Buffer
|
|
|
|
err := json.Indent(&out, []byte(in), "", " ")
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return out.String()
|
|
|
|
},
|
2017-09-12 05:25:42 -04:00
|
|
|
"DisableGitHooks": func() bool {
|
|
|
|
return setting.DisableGitHooks
|
|
|
|
},
|
2021-02-11 12:34:34 -05:00
|
|
|
"DisableWebhooks": func() bool {
|
|
|
|
return setting.DisableWebhooks
|
|
|
|
},
|
2018-08-24 01:00:22 -04:00
|
|
|
"DisableImportLocal": func() bool {
|
|
|
|
return !setting.ImportLocalPaths
|
|
|
|
},
|
2017-12-03 18:14:26 -05:00
|
|
|
"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
|
|
|
|
},
|
2018-04-29 01:58:47 -04:00
|
|
|
"Printf": fmt.Sprintf,
|
|
|
|
"Escape": Escape,
|
2022-02-15 11:50:10 -05:00
|
|
|
"Sec2Time": util.SecToTime,
|
2018-05-01 15:05:28 -04:00
|
|
|
"ParseDeadline": func(deadline string) []string {
|
|
|
|
return strings.Split(deadline, "|")
|
|
|
|
},
|
2018-07-05 17:25:04 -04:00
|
|
|
"DefaultTheme": func() string {
|
|
|
|
return setting.UI.DefaultTheme
|
|
|
|
},
|
2020-11-25 06:20:40 -05:00
|
|
|
// pass key-value pairs to a partial template which receives them as a dict
|
2018-08-06 00:43:22 -04:00
|
|
|
"dict": func(values ...interface{}) (map[string]interface{}, error) {
|
|
|
|
if len(values) == 0 {
|
|
|
|
return nil, errors.New("invalid dict call")
|
|
|
|
}
|
|
|
|
|
|
|
|
dict := make(map[string]interface{})
|
2020-11-25 06:20:40 -05:00
|
|
|
return util.MergeInto(dict, values...)
|
|
|
|
},
|
|
|
|
/* like dict but merge key-value pairs into the first dict and return it */
|
|
|
|
"mergeinto": func(root map[string]interface{}, values ...interface{}) (map[string]interface{}, error) {
|
|
|
|
if len(values) == 0 {
|
|
|
|
return nil, errors.New("invalid mergeinto call")
|
|
|
|
}
|
2018-08-06 00:43:22 -04:00
|
|
|
|
2020-11-25 06:20:40 -05:00
|
|
|
dict := make(map[string]interface{})
|
|
|
|
for key, value := range root {
|
|
|
|
dict[key] = value
|
2018-08-06 00:43:22 -04:00
|
|
|
}
|
2020-11-25 06:20:40 -05:00
|
|
|
|
|
|
|
return util.MergeInto(dict, values...)
|
2018-08-06 00:43:22 -04:00
|
|
|
},
|
2019-05-05 12:25:25 -04:00
|
|
|
"percentage": func(n int, values ...int) float32 {
|
2022-01-20 12:46:10 -05:00
|
|
|
sum := 0
|
2019-05-05 12:25:25 -04:00
|
|
|
for i := 0; i < len(values); i++ {
|
|
|
|
sum += values[i]
|
|
|
|
}
|
|
|
|
return float32(n) * 100 / float32(sum)
|
|
|
|
},
|
2021-06-14 13:20:43 -04:00
|
|
|
"CommentMustAsDiff": gitdiff.CommentMustAsDiff,
|
|
|
|
"MirrorRemoteAddress": mirrorRemoteAddress,
|
2020-07-03 05:55:36 -04:00
|
|
|
"NotificationSettings": func() map[string]interface{} {
|
|
|
|
return map[string]interface{}{
|
2020-05-07 17:49:00 -04:00
|
|
|
"MinTimeout": int(setting.UI.Notification.MinTimeout / time.Millisecond),
|
|
|
|
"TimeoutStep": int(setting.UI.Notification.TimeoutStep / time.Millisecond),
|
|
|
|
"MaxTimeout": int(setting.UI.Notification.MaxTimeout / time.Millisecond),
|
|
|
|
"EventSourceUpdateTime": int(setting.UI.Notification.EventSourceUpdateTime / time.Millisecond),
|
2020-04-23 23:57:38 -04:00
|
|
|
}
|
|
|
|
},
|
2022-01-20 12:46:10 -05:00
|
|
|
"containGeneric": func(arr, v interface{}) bool {
|
2020-11-08 12:21:54 -05:00
|
|
|
arrV := reflect.ValueOf(arr)
|
|
|
|
if arrV.Kind() == reflect.String && reflect.ValueOf(v).Kind() == reflect.String {
|
|
|
|
return strings.Contains(arr.(string), v.(string))
|
|
|
|
}
|
|
|
|
|
|
|
|
if arrV.Kind() == reflect.Slice {
|
|
|
|
for i := 0; i < arrV.Len(); i++ {
|
|
|
|
iV := arrV.Index(i)
|
|
|
|
if !iV.CanInterface() {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if iV.Interface() == v {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
},
|
2019-12-28 09:43:46 -05:00
|
|
|
"contain": func(s []int64, id int64) bool {
|
|
|
|
for i := 0; i < len(s); i++ {
|
|
|
|
if s[i] == id {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
},
|
2022-11-08 10:13:58 -05:00
|
|
|
"svg": svg.RenderHTML,
|
2020-12-09 00:11:15 -05:00
|
|
|
"avatar": Avatar,
|
|
|
|
"avatarHTML": AvatarHTML,
|
|
|
|
"avatarByAction": AvatarByAction,
|
|
|
|
"avatarByEmail": AvatarByEmail,
|
|
|
|
"repoAvatar": RepoAvatar,
|
2020-06-24 18:23:05 -04:00
|
|
|
"SortArrow": func(normSort, revSort, urlSort string, isDefault bool) template.HTML {
|
|
|
|
// if needed
|
|
|
|
if len(normSort) == 0 || len(urlSort) == 0 {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(urlSort) == 0 && isDefault {
|
|
|
|
// if sort is sorted as default add arrow tho this table header
|
|
|
|
if isDefault {
|
2022-11-08 10:13:58 -05:00
|
|
|
return svg.RenderHTML("octicon-triangle-down", 16)
|
2020-06-24 18:23:05 -04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// if sort arg is in url test if it correlates with column header sort arguments
|
2021-10-12 14:11:35 -04:00
|
|
|
// the direction of the arrow should indicate the "current sort order", up means ASC(normal), down means DESC(rev)
|
2020-06-24 18:23:05 -04:00
|
|
|
if urlSort == normSort {
|
|
|
|
// the table is sorted with this header normal
|
2022-11-08 10:13:58 -05:00
|
|
|
return svg.RenderHTML("octicon-triangle-up", 16)
|
2020-06-24 18:23:05 -04:00
|
|
|
} else if urlSort == revSort {
|
|
|
|
// the table is sorted with this header reverse
|
2022-11-08 10:13:58 -05:00
|
|
|
return svg.RenderHTML("octicon-triangle-down", 16)
|
2020-06-24 18:23:05 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// the table is NOT sorted with this header
|
|
|
|
return ""
|
2020-02-11 12:02:41 -05:00
|
|
|
},
|
2022-09-12 13:45:14 -04:00
|
|
|
"RenderLabels": func(labels []*issues_model.Label, repoLink string) template.HTML {
|
2022-09-16 08:44:00 -04:00
|
|
|
htmlCode := `<span class="labels-list">`
|
2020-10-25 17:49:48 -04:00
|
|
|
for _, label := range labels {
|
2021-02-09 21:50:44 -05:00
|
|
|
// Protect against nil value in labels - shouldn't happen but would cause a panic if so
|
|
|
|
if label == nil {
|
|
|
|
continue
|
|
|
|
}
|
2022-09-16 08:44:00 -04:00
|
|
|
htmlCode += fmt.Sprintf("<a href='%s/issues?labels=%d' class='ui label' style='color: %s !important; background-color: %s !important' title='%s'>%s</a> ",
|
|
|
|
repoLink, label.ID, label.ForegroundColor(), label.Color, html.EscapeString(label.Description), RenderEmoji(label.Name))
|
2020-10-25 17:49:48 -04:00
|
|
|
}
|
2022-09-16 08:44:00 -04:00
|
|
|
htmlCode += "</span>"
|
|
|
|
return template.HTML(htmlCode)
|
2020-10-25 17:49:48 -04:00
|
|
|
},
|
2021-07-24 00:21:51 -04:00
|
|
|
"MermaidMaxSourceCharacters": func() int {
|
|
|
|
return setting.MermaidMaxSourceCharacters
|
|
|
|
},
|
2021-12-14 03:37:11 -05:00
|
|
|
"Join": strings.Join,
|
2021-11-02 11:00:30 -04:00
|
|
|
"QueryEscape": url.QueryEscape,
|
2022-03-23 12:08:27 -04:00
|
|
|
"DotEscape": DotEscape,
|
2022-06-08 04:59:16 -04:00
|
|
|
"Iterate": func(arg interface{}) (items []uint64) {
|
|
|
|
count := uint64(0)
|
|
|
|
switch val := arg.(type) {
|
|
|
|
case uint64:
|
|
|
|
count = val
|
|
|
|
case *uint64:
|
|
|
|
count = *val
|
|
|
|
case int64:
|
|
|
|
if val < 0 {
|
|
|
|
val = 0
|
|
|
|
}
|
|
|
|
count = uint64(val)
|
|
|
|
case *int64:
|
|
|
|
if *val < 0 {
|
|
|
|
*val = 0
|
|
|
|
}
|
|
|
|
count = uint64(*val)
|
|
|
|
case int:
|
|
|
|
if val < 0 {
|
|
|
|
val = 0
|
|
|
|
}
|
|
|
|
count = uint64(val)
|
|
|
|
case *int:
|
|
|
|
if *val < 0 {
|
|
|
|
*val = 0
|
|
|
|
}
|
|
|
|
count = uint64(*val)
|
|
|
|
case uint:
|
|
|
|
count = uint64(val)
|
|
|
|
case *uint:
|
|
|
|
count = uint64(*val)
|
|
|
|
case int32:
|
|
|
|
if val < 0 {
|
|
|
|
val = 0
|
|
|
|
}
|
|
|
|
count = uint64(val)
|
|
|
|
case *int32:
|
|
|
|
if *val < 0 {
|
|
|
|
*val = 0
|
|
|
|
}
|
|
|
|
count = uint64(*val)
|
|
|
|
case uint32:
|
|
|
|
count = uint64(val)
|
|
|
|
case *uint32:
|
|
|
|
count = uint64(*val)
|
|
|
|
case string:
|
|
|
|
cnt, _ := strconv.ParseInt(val, 10, 64)
|
|
|
|
if cnt < 0 {
|
|
|
|
cnt = 0
|
|
|
|
}
|
|
|
|
count = uint64(cnt)
|
|
|
|
}
|
|
|
|
if count <= 0 {
|
|
|
|
return items
|
|
|
|
}
|
|
|
|
for i := uint64(0); i < count; i++ {
|
|
|
|
items = append(items, i)
|
|
|
|
}
|
|
|
|
return items
|
|
|
|
},
|
2022-08-20 10:47:04 -04:00
|
|
|
"HasPrefix": strings.HasPrefix,
|
2022-10-21 04:39:26 -04:00
|
|
|
"CompareLink": func(baseRepo, repo *repo_model.Repository, branchName string) string {
|
|
|
|
var curBranch string
|
|
|
|
if repo.ID != baseRepo.ID {
|
|
|
|
curBranch += fmt.Sprintf("%s/%s:", url.PathEscape(repo.OwnerName), url.PathEscape(repo.Name))
|
|
|
|
}
|
|
|
|
curBranch += util.PathEscapeSegments(branchName)
|
|
|
|
|
|
|
|
return fmt.Sprintf("%s/compare/%s...%s",
|
|
|
|
baseRepo.Link(),
|
|
|
|
util.PathEscapeSegments(baseRepo.DefaultBranch),
|
|
|
|
curBranch,
|
|
|
|
)
|
|
|
|
},
|
2016-03-06 16:40:04 -05:00
|
|
|
}}
|
2015-11-13 22:45:33 -05:00
|
|
|
}
|
|
|
|
|
2019-11-07 08:34:28 -05:00
|
|
|
// NewTextFuncMap returns functions for injecting to text templates
|
|
|
|
// It's a subset of those used for HTML and other templates
|
|
|
|
func NewTextFuncMap() []texttmpl.FuncMap {
|
|
|
|
return []texttmpl.FuncMap{map[string]interface{}{
|
|
|
|
"GoVer": func() string {
|
2022-05-10 17:55:54 -04:00
|
|
|
return util.ToTitleCase(runtime.Version())
|
2019-11-07 08:34:28 -05:00
|
|
|
},
|
|
|
|
"AppName": func() string {
|
|
|
|
return setting.AppName
|
|
|
|
},
|
|
|
|
"AppSubUrl": func() string {
|
|
|
|
return setting.AppSubURL
|
|
|
|
},
|
|
|
|
"AppUrl": func() string {
|
|
|
|
return setting.AppURL
|
|
|
|
},
|
|
|
|
"AppVer": func() string {
|
|
|
|
return setting.AppVer
|
|
|
|
},
|
|
|
|
"AppBuiltWith": func() string {
|
|
|
|
return setting.AppBuiltWith
|
|
|
|
},
|
|
|
|
"AppDomain": func() string {
|
|
|
|
return setting.Domain
|
|
|
|
},
|
|
|
|
"TimeSince": timeutil.TimeSince,
|
|
|
|
"TimeSinceUnix": timeutil.TimeSinceUnix,
|
|
|
|
"DateFmtLong": func(t time.Time) string {
|
|
|
|
return t.Format(time.RFC1123Z)
|
|
|
|
},
|
|
|
|
"DateFmtShort": func(t time.Time) string {
|
|
|
|
return t.Format("Jan 02, 2006")
|
|
|
|
},
|
|
|
|
"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]
|
|
|
|
},
|
|
|
|
"EllipsisString": base.EllipsisString,
|
|
|
|
"URLJoin": util.URLJoin,
|
|
|
|
"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
|
|
|
|
},
|
|
|
|
"Printf": fmt.Sprintf,
|
|
|
|
"Escape": Escape,
|
2022-02-15 11:50:10 -05:00
|
|
|
"Sec2Time": util.SecToTime,
|
2019-11-07 08:34:28 -05:00
|
|
|
"ParseDeadline": func(deadline string) []string {
|
|
|
|
return strings.Split(deadline, "|")
|
|
|
|
},
|
|
|
|
"dict": func(values ...interface{}) (map[string]interface{}, error) {
|
|
|
|
if len(values) == 0 {
|
|
|
|
return nil, errors.New("invalid dict call")
|
|
|
|
}
|
|
|
|
|
|
|
|
dict := make(map[string]interface{})
|
|
|
|
|
|
|
|
for i := 0; i < len(values); i++ {
|
|
|
|
switch key := values[i].(type) {
|
|
|
|
case string:
|
|
|
|
i++
|
|
|
|
if i == len(values) {
|
|
|
|
return nil, errors.New("specify the key for non array values")
|
|
|
|
}
|
|
|
|
dict[key] = values[i]
|
|
|
|
case map[string]interface{}:
|
|
|
|
m := values[i].(map[string]interface{})
|
|
|
|
for i, v := range m {
|
|
|
|
dict[i] = v
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return nil, errors.New("dict values must be maps")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return dict, nil
|
|
|
|
},
|
|
|
|
"percentage": func(n int, values ...int) float32 {
|
2022-01-20 12:46:10 -05:00
|
|
|
sum := 0
|
2019-11-07 08:34:28 -05:00
|
|
|
for i := 0; i < len(values); i++ {
|
|
|
|
sum += values[i]
|
|
|
|
}
|
|
|
|
return float32(n) * 100 / float32(sum)
|
|
|
|
},
|
2020-08-06 04:04:08 -04:00
|
|
|
"Add": func(a ...int) int {
|
|
|
|
sum := 0
|
|
|
|
for _, val := range a {
|
|
|
|
sum += val
|
|
|
|
}
|
|
|
|
return sum
|
|
|
|
},
|
|
|
|
"Mul": func(a ...int) int {
|
|
|
|
sum := 1
|
|
|
|
for _, val := range a {
|
|
|
|
sum *= val
|
|
|
|
}
|
|
|
|
return sum
|
|
|
|
},
|
2021-11-02 02:26:13 -04:00
|
|
|
"QueryEscape": url.QueryEscape,
|
2019-11-07 08:34:28 -05:00
|
|
|
}}
|
|
|
|
}
|
|
|
|
|
2020-12-08 19:12:15 -05:00
|
|
|
// AvatarHTML creates the HTML for an avatar
|
2021-12-19 23:41:31 -05:00
|
|
|
func AvatarHTML(src string, size int, class, name string) template.HTML {
|
2020-12-03 13:46:11 -05:00
|
|
|
sizeStr := fmt.Sprintf(`%d`, size)
|
|
|
|
|
|
|
|
if name == "" {
|
|
|
|
name = "avatar"
|
2020-09-08 13:17:56 -04:00
|
|
|
}
|
|
|
|
|
2020-12-03 13:46:11 -05:00
|
|
|
return template.HTML(`<img class="` + class + `" src="` + src + `" title="` + html.EscapeString(name) + `" width="` + sizeStr + `" height="` + sizeStr + `"/>`)
|
|
|
|
}
|
|
|
|
|
2020-12-07 23:14:28 -05:00
|
|
|
// Avatar renders user avatars. args: user, size (int), class (string)
|
2020-12-10 00:44:13 -05:00
|
|
|
func Avatar(item interface{}, others ...interface{}) template.HTML {
|
2022-11-08 10:13:58 -05:00
|
|
|
size, class := gitea_html.ParseSizeAndClass(avatars.DefaultAvatarPixelSize, "ui avatar vm", others...)
|
2020-12-03 13:46:11 -05:00
|
|
|
|
2021-11-23 22:51:08 -05:00
|
|
|
switch t := item.(type) {
|
2021-11-24 04:49:20 -05:00
|
|
|
case *user_model.User:
|
2021-12-15 21:18:38 -05:00
|
|
|
src := t.AvatarLinkWithSize(size * setting.Avatar.RenderedSizeFactor)
|
2020-12-10 00:44:13 -05:00
|
|
|
if src != "" {
|
2021-11-23 22:51:08 -05:00
|
|
|
return AvatarHTML(src, size, class, t.DisplayName())
|
2020-12-10 00:44:13 -05:00
|
|
|
}
|
2022-05-11 06:09:36 -04:00
|
|
|
case *repo_model.Collaborator:
|
2021-12-15 21:18:38 -05:00
|
|
|
src := t.AvatarLinkWithSize(size * setting.Avatar.RenderedSizeFactor)
|
2021-11-23 22:51:08 -05:00
|
|
|
if src != "" {
|
|
|
|
return AvatarHTML(src, size, class, t.DisplayName())
|
|
|
|
}
|
2022-03-29 02:29:02 -04:00
|
|
|
case *organization.Organization:
|
2021-12-15 21:18:38 -05:00
|
|
|
src := t.AsUser().AvatarLinkWithSize(size * setting.Avatar.RenderedSizeFactor)
|
2020-12-10 00:44:13 -05:00
|
|
|
if src != "" {
|
2021-11-23 22:51:08 -05:00
|
|
|
return AvatarHTML(src, size, class, t.AsUser().DisplayName())
|
2020-12-10 00:44:13 -05:00
|
|
|
}
|
2020-12-03 13:46:11 -05:00
|
|
|
}
|
2021-11-23 22:51:08 -05:00
|
|
|
|
2020-12-07 23:14:28 -05:00
|
|
|
return template.HTML("")
|
|
|
|
}
|
|
|
|
|
2020-12-09 00:11:15 -05:00
|
|
|
// AvatarByAction renders user avatars from action. args: action, size (int), class (string)
|
2022-08-24 22:31:57 -04:00
|
|
|
func AvatarByAction(action *activities_model.Action, others ...interface{}) template.HTML {
|
2020-12-09 00:11:15 -05:00
|
|
|
action.LoadActUser()
|
|
|
|
return Avatar(action.ActUser, others...)
|
|
|
|
}
|
|
|
|
|
2020-12-07 23:14:28 -05:00
|
|
|
// RepoAvatar renders repo avatars. args: repo, size(int), class (string)
|
2021-12-09 20:27:50 -05:00
|
|
|
func RepoAvatar(repo *repo_model.Repository, others ...interface{}) template.HTML {
|
2022-11-08 10:13:58 -05:00
|
|
|
size, class := gitea_html.ParseSizeAndClass(avatars.DefaultAvatarPixelSize, "ui avatar", others...)
|
2020-12-03 13:46:11 -05:00
|
|
|
|
2020-12-07 23:14:28 -05:00
|
|
|
src := repo.RelAvatarLink()
|
|
|
|
if src != "" {
|
2020-12-08 19:12:15 -05:00
|
|
|
return AvatarHTML(src, size, class, repo.FullName())
|
2020-12-07 23:14:28 -05:00
|
|
|
}
|
2020-12-03 13:46:11 -05:00
|
|
|
return template.HTML("")
|
|
|
|
}
|
|
|
|
|
|
|
|
// AvatarByEmail renders avatars by email address. args: email, name, size (int), class (string)
|
2021-12-19 23:41:31 -05:00
|
|
|
func AvatarByEmail(email, name string, others ...interface{}) template.HTML {
|
2022-11-08 10:13:58 -05:00
|
|
|
size, class := gitea_html.ParseSizeAndClass(avatars.DefaultAvatarPixelSize, "ui avatar", others...)
|
2021-12-15 21:18:38 -05:00
|
|
|
src := avatars.GenerateEmailAvatarFastLink(email, size*setting.Avatar.RenderedSizeFactor)
|
2020-12-03 13:46:11 -05:00
|
|
|
|
|
|
|
if src != "" {
|
2020-12-08 19:12:15 -05:00
|
|
|
return AvatarHTML(src, size, class, name)
|
2020-12-03 13:46:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return template.HTML("")
|
|
|
|
}
|
|
|
|
|
2016-11-25 01:23:48 -05:00
|
|
|
// Safe render raw as HTML
|
2015-08-08 05:10:34 -04:00
|
|
|
func Safe(raw string) template.HTML {
|
|
|
|
return template.HTML(raw)
|
|
|
|
}
|
|
|
|
|
2017-08-23 10:58:05 -04:00
|
|
|
// SafeJS renders raw as JS
|
|
|
|
func SafeJS(raw string) template.JS {
|
|
|
|
return template.JS(raw)
|
|
|
|
}
|
|
|
|
|
2016-11-25 01:23:48 -05:00
|
|
|
// Str2html render Markdown text to HTML
|
2014-04-10 14:20:58 -04:00
|
|
|
func Str2html(raw string) template.HTML {
|
2017-09-16 13:17:57 -04:00
|
|
|
return template.HTML(markup.Sanitize(raw))
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2018-02-11 08:42:28 -05:00
|
|
|
// Escape escapes a HTML string
|
|
|
|
func Escape(raw string) string {
|
|
|
|
return html.EscapeString(raw)
|
|
|
|
}
|
|
|
|
|
2021-03-11 23:43:04 -05:00
|
|
|
// JSEscape escapes a JS string
|
|
|
|
func JSEscape(raw string) string {
|
|
|
|
return template.JSEscapeString(raw)
|
|
|
|
}
|
|
|
|
|
2022-03-23 08:34:20 -04:00
|
|
|
// DotEscape wraps a dots in names with ZWJ [U+200D] in order to prevent autolinkers from detecting these as urls
|
|
|
|
func DotEscape(raw string) string {
|
|
|
|
return strings.ReplaceAll(raw, ".", "\u200d.\u200d")
|
|
|
|
}
|
|
|
|
|
2015-01-30 18:05:20 -05:00
|
|
|
// RenderCommitMessage renders commit message with XSS-safe and special links.
|
2022-01-19 18:26:57 -05:00
|
|
|
func RenderCommitMessage(ctx context.Context, msg, urlPrefix string, metas map[string]string) template.HTML {
|
|
|
|
return RenderCommitMessageLink(ctx, msg, urlPrefix, "", metas)
|
2017-11-12 20:35:55 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// RenderCommitMessageLink renders commit message as a XXS-safe link to the provided
|
|
|
|
// default url, handling for special links.
|
2022-01-19 18:26:57 -05:00
|
|
|
func RenderCommitMessageLink(ctx context.Context, msg, urlPrefix, urlDefault string, metas map[string]string) template.HTML {
|
2015-09-18 21:57:06 -04:00
|
|
|
cleanMsg := template.HTMLEscapeString(msg)
|
2018-02-27 02:09:18 -05:00
|
|
|
// we can safely assume that it will not return any error, since there
|
|
|
|
// shouldn't be any special HTML.
|
2021-04-19 18:25:08 -04:00
|
|
|
fullMessage, err := markup.RenderCommitMessage(&markup.RenderContext{
|
2022-01-19 18:26:57 -05:00
|
|
|
Ctx: ctx,
|
2021-04-19 18:25:08 -04:00
|
|
|
URLPrefix: urlPrefix,
|
|
|
|
DefaultLink: urlDefault,
|
|
|
|
Metas: metas,
|
|
|
|
}, cleanMsg)
|
2018-02-27 02:09:18 -05:00
|
|
|
if err != nil {
|
2019-04-02 03:48:31 -04:00
|
|
|
log.Error("RenderCommitMessage: %v", err)
|
2018-02-27 02:09:18 -05:00
|
|
|
return ""
|
|
|
|
}
|
2022-06-20 06:02:49 -04:00
|
|
|
msgLines := strings.Split(strings.TrimSpace(fullMessage), "\n")
|
2017-11-12 20:35:55 -05:00
|
|
|
if len(msgLines) == 0 {
|
2015-12-06 18:18:12 -05:00
|
|
|
return template.HTML("")
|
2015-09-18 21:57:06 -04:00
|
|
|
}
|
2017-11-12 20:35:55 -05:00
|
|
|
return template.HTML(msgLines[0])
|
2015-01-30 18:05:20 -05:00
|
|
|
}
|
|
|
|
|
2019-09-10 05:03:30 -04:00
|
|
|
// RenderCommitMessageLinkSubject renders commit message as a XXS-safe link to
|
|
|
|
// the provided default url, handling for special links without email to links.
|
2022-01-19 18:26:57 -05:00
|
|
|
func RenderCommitMessageLinkSubject(ctx context.Context, msg, urlPrefix, urlDefault string, metas map[string]string) template.HTML {
|
2019-11-01 00:48:30 -04:00
|
|
|
msgLine := strings.TrimLeftFunc(msg, unicode.IsSpace)
|
|
|
|
lineEnd := strings.IndexByte(msgLine, '\n')
|
|
|
|
if lineEnd > 0 {
|
|
|
|
msgLine = msgLine[:lineEnd]
|
|
|
|
}
|
|
|
|
msgLine = strings.TrimRightFunc(msgLine, unicode.IsSpace)
|
|
|
|
if len(msgLine) == 0 {
|
|
|
|
return template.HTML("")
|
|
|
|
}
|
|
|
|
|
2019-09-10 05:03:30 -04:00
|
|
|
// we can safely assume that it will not return any error, since there
|
|
|
|
// shouldn't be any special HTML.
|
2021-04-19 18:25:08 -04:00
|
|
|
renderedMessage, err := markup.RenderCommitMessageSubject(&markup.RenderContext{
|
2022-01-19 18:26:57 -05:00
|
|
|
Ctx: ctx,
|
2021-04-19 18:25:08 -04:00
|
|
|
URLPrefix: urlPrefix,
|
|
|
|
DefaultLink: urlDefault,
|
|
|
|
Metas: metas,
|
|
|
|
}, template.HTMLEscapeString(msgLine))
|
2019-09-10 05:03:30 -04:00
|
|
|
if err != nil {
|
|
|
|
log.Error("RenderCommitMessageSubject: %v", err)
|
|
|
|
return template.HTML("")
|
|
|
|
}
|
2019-11-01 00:48:30 -04:00
|
|
|
return template.HTML(renderedMessage)
|
2019-09-10 05:03:30 -04:00
|
|
|
}
|
|
|
|
|
2017-11-30 00:08:40 -05:00
|
|
|
// RenderCommitBody extracts the body of a commit message without its title.
|
2022-01-19 18:26:57 -05:00
|
|
|
func RenderCommitBody(ctx context.Context, msg, urlPrefix string, metas map[string]string) template.HTML {
|
2019-11-01 00:48:30 -04:00
|
|
|
msgLine := strings.TrimRightFunc(msg, unicode.IsSpace)
|
|
|
|
lineEnd := strings.IndexByte(msgLine, '\n')
|
|
|
|
if lineEnd > 0 {
|
|
|
|
msgLine = msgLine[lineEnd+1:]
|
|
|
|
} else {
|
|
|
|
return template.HTML("")
|
|
|
|
}
|
|
|
|
msgLine = strings.TrimLeftFunc(msgLine, unicode.IsSpace)
|
|
|
|
if len(msgLine) == 0 {
|
|
|
|
return template.HTML("")
|
|
|
|
}
|
|
|
|
|
2021-04-19 18:25:08 -04:00
|
|
|
renderedMessage, err := markup.RenderCommitMessage(&markup.RenderContext{
|
2022-01-19 18:26:57 -05:00
|
|
|
Ctx: ctx,
|
2021-04-19 18:25:08 -04:00
|
|
|
URLPrefix: urlPrefix,
|
|
|
|
Metas: metas,
|
|
|
|
}, template.HTMLEscapeString(msgLine))
|
2018-02-27 02:09:18 -05:00
|
|
|
if err != nil {
|
2019-04-02 03:48:31 -04:00
|
|
|
log.Error("RenderCommitMessage: %v", err)
|
2018-02-27 02:09:18 -05:00
|
|
|
return ""
|
|
|
|
}
|
2019-11-01 00:48:30 -04:00
|
|
|
return template.HTML(renderedMessage)
|
2017-11-30 00:08:40 -05:00
|
|
|
}
|
|
|
|
|
2022-10-15 14:24:41 -04:00
|
|
|
// Match text that is between back ticks.
|
|
|
|
var codeMatcher = regexp.MustCompile("`([^`]+)`")
|
|
|
|
|
|
|
|
// RenderCodeBlock renders "`…`" as highlighted "<code>" block.
|
|
|
|
// Intended for issue and PR titles, these containers should have styles for "<code>" elements
|
|
|
|
func RenderCodeBlock(htmlEscapedTextToRender template.HTML) template.HTML {
|
|
|
|
htmlWithCodeTags := codeMatcher.ReplaceAllString(string(htmlEscapedTextToRender), "<code>$1</code>") // replace with HTML <code> tags
|
|
|
|
return template.HTML(htmlWithCodeTags)
|
|
|
|
}
|
|
|
|
|
2020-12-03 05:50:47 -05:00
|
|
|
// RenderIssueTitle renders issue/pull title with defined post processors
|
2022-01-19 18:26:57 -05:00
|
|
|
func RenderIssueTitle(ctx context.Context, text, urlPrefix string, metas map[string]string) template.HTML {
|
2021-04-19 18:25:08 -04:00
|
|
|
renderedText, err := markup.RenderIssueTitle(&markup.RenderContext{
|
2022-01-19 18:26:57 -05:00
|
|
|
Ctx: ctx,
|
2021-04-19 18:25:08 -04:00
|
|
|
URLPrefix: urlPrefix,
|
|
|
|
Metas: metas,
|
|
|
|
}, template.HTMLEscapeString(text))
|
2020-12-03 05:50:47 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Error("RenderIssueTitle: %v", err)
|
|
|
|
return template.HTML("")
|
|
|
|
}
|
|
|
|
return template.HTML(renderedText)
|
|
|
|
}
|
|
|
|
|
2020-04-28 14:05:39 -04:00
|
|
|
// RenderEmoji renders html text with emoji post processors
|
|
|
|
func RenderEmoji(text string) template.HTML {
|
2021-04-19 18:25:08 -04:00
|
|
|
renderedText, err := markup.RenderEmoji(template.HTMLEscapeString(text))
|
2020-04-28 14:05:39 -04:00
|
|
|
if err != nil {
|
|
|
|
log.Error("RenderEmoji: %v", err)
|
|
|
|
return template.HTML("")
|
|
|
|
}
|
|
|
|
return template.HTML(renderedText)
|
|
|
|
}
|
|
|
|
|
2022-01-20 12:46:10 -05:00
|
|
|
// ReactionToEmoji renders emoji for use in reactions
|
2020-04-28 14:05:39 -04:00
|
|
|
func ReactionToEmoji(reaction string) template.HTML {
|
|
|
|
val := emoji.FromCode(reaction)
|
|
|
|
if val != nil {
|
|
|
|
return template.HTML(val.Emoji)
|
|
|
|
}
|
|
|
|
val = emoji.FromAlias(reaction)
|
|
|
|
if val != nil {
|
|
|
|
return template.HTML(val.Emoji)
|
|
|
|
}
|
2021-11-16 13:18:25 -05:00
|
|
|
return template.HTML(fmt.Sprintf(`<img alt=":%s:" src="%s/assets/img/emoji/%s.png"></img>`, reaction, setting.StaticURLPrefix, url.PathEscape(reaction)))
|
2020-04-28 14:05:39 -04:00
|
|
|
}
|
|
|
|
|
2019-05-24 03:52:05 -04:00
|
|
|
// RenderNote renders the contents of a git-notes file as a commit message.
|
2022-01-19 18:26:57 -05:00
|
|
|
func RenderNote(ctx context.Context, msg, urlPrefix string, metas map[string]string) template.HTML {
|
2019-05-24 03:52:05 -04:00
|
|
|
cleanMsg := template.HTMLEscapeString(msg)
|
2021-04-19 18:25:08 -04:00
|
|
|
fullMessage, err := markup.RenderCommitMessage(&markup.RenderContext{
|
2022-01-19 18:26:57 -05:00
|
|
|
Ctx: ctx,
|
2021-04-19 18:25:08 -04:00
|
|
|
URLPrefix: urlPrefix,
|
|
|
|
Metas: metas,
|
|
|
|
}, cleanMsg)
|
2019-05-24 03:52:05 -04:00
|
|
|
if err != nil {
|
|
|
|
log.Error("RenderNote: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
2022-06-20 06:02:49 -04:00
|
|
|
return template.HTML(fullMessage)
|
2019-05-24 03:52:05 -04:00
|
|
|
}
|
|
|
|
|
2017-11-30 00:08:40 -05:00
|
|
|
// IsMultilineCommitMessage checks to see if a commit message contains multiple lines.
|
|
|
|
func IsMultilineCommitMessage(msg string) bool {
|
2018-06-15 10:07:48 -04:00
|
|
|
return strings.Count(strings.TrimSpace(msg), "\n") >= 1
|
2017-11-30 00:08:40 -05:00
|
|
|
}
|
|
|
|
|
2016-11-25 01:23:48 -05:00
|
|
|
// Actioner describes an action
|
2014-04-10 14:20:58 -04:00
|
|
|
type Actioner interface {
|
2022-08-24 22:31:57 -04:00
|
|
|
GetOpType() activities_model.ActionType
|
2014-04-10 14:20:58 -04:00
|
|
|
GetActUserName() string
|
2014-05-09 02:42:50 -04:00
|
|
|
GetRepoUserName() string
|
2014-04-10 14:20:58 -04:00
|
|
|
GetRepoName() string
|
2015-09-01 09:29:52 -04:00
|
|
|
GetRepoPath() string
|
|
|
|
GetRepoLink() string
|
2014-04-10 14:20:58 -04:00
|
|
|
GetBranch() string
|
|
|
|
GetContent() string
|
2015-09-01 09:29:52 -04:00
|
|
|
GetCreate() time.Time
|
|
|
|
GetIssueInfos() []string
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
|
2017-09-19 21:22:42 -04:00
|
|
|
// ActionIcon accepts an action operation type and returns an icon class name.
|
2022-08-24 22:31:57 -04:00
|
|
|
func ActionIcon(opType activities_model.ActionType) string {
|
2014-04-10 14:20:58 -04:00
|
|
|
switch opType {
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionCreateRepo, activities_model.ActionTransferRepo, activities_model.ActionRenameRepo:
|
2014-07-26 00:24:27 -04:00
|
|
|
return "repo"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionCommitRepo, activities_model.ActionPushTag, activities_model.ActionDeleteTag, activities_model.ActionDeleteBranch:
|
2014-07-26 00:24:27 -04:00
|
|
|
return "git-commit"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionCreateIssue:
|
2014-07-26 00:24:27 -04:00
|
|
|
return "issue-opened"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionCreatePullRequest:
|
2015-11-16 11:39:48 -05:00
|
|
|
return "git-pull-request"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionCommentIssue, activities_model.ActionCommentPull:
|
2016-07-16 00:45:13 -04:00
|
|
|
return "comment-discussion"
|
2022-11-03 11:49:00 -04:00
|
|
|
case activities_model.ActionMergePullRequest, activities_model.ActionAutoMergePullRequest:
|
2015-11-16 11:39:48 -05:00
|
|
|
return "git-merge"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionCloseIssue, activities_model.ActionClosePullRequest:
|
2016-02-22 12:40:00 -05:00
|
|
|
return "issue-closed"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionReopenIssue, activities_model.ActionReopenPullRequest:
|
2016-03-05 12:58:51 -05:00
|
|
|
return "issue-reopened"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionMirrorSyncPush, activities_model.ActionMirrorSyncCreate, activities_model.ActionMirrorSyncDelete:
|
2020-12-10 18:06:45 -05:00
|
|
|
return "mirror"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionApprovePullRequest:
|
2020-04-24 00:58:14 -04:00
|
|
|
return "check"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionRejectPullRequest:
|
2020-07-17 11:15:12 -04:00
|
|
|
return "diff"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionPublishRelease:
|
2020-07-29 15:20:54 -04:00
|
|
|
return "tag"
|
2022-08-24 22:31:57 -04:00
|
|
|
case activities_model.ActionPullReviewDismissed:
|
2021-02-11 12:32:25 -05:00
|
|
|
return "x"
|
2014-04-10 14:20:58 -04:00
|
|
|
default:
|
2020-04-24 00:58:14 -04:00
|
|
|
return "question"
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-25 01:23:48 -05:00
|
|
|
// ActionContent2Commits converts action content to push commits
|
2020-01-10 04:34:21 -05:00
|
|
|
func ActionContent2Commits(act Actioner) *repository.PushCommits {
|
|
|
|
push := repository.NewPushCommits()
|
2021-03-01 16:08:10 -05:00
|
|
|
|
2021-03-05 23:09:49 -05:00
|
|
|
if act == nil || act.GetContent() == "" {
|
|
|
|
return push
|
|
|
|
}
|
|
|
|
|
2015-11-13 17:10:25 -05:00
|
|
|
if err := json.Unmarshal([]byte(act.GetContent()), push); err != nil {
|
2019-04-02 03:48:31 -04:00
|
|
|
log.Error("json.Unmarshal:\n%s\nERROR: %v", act.GetContent(), err)
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
2021-08-25 19:04:58 -04:00
|
|
|
|
|
|
|
if push.Len == 0 {
|
|
|
|
push.Len = len(push.Commits)
|
|
|
|
}
|
|
|
|
|
2014-07-26 00:24:27 -04:00
|
|
|
return push
|
|
|
|
}
|
|
|
|
|
2016-11-25 01:23:48 -05:00
|
|
|
// DiffTypeToStr returns diff type name
|
2014-04-10 14:20:58 -04:00
|
|
|
func DiffTypeToStr(diffType int) string {
|
|
|
|
diffTypes := map[int]string{
|
2020-09-09 09:08:40 -04:00
|
|
|
1: "add", 2: "modify", 3: "del", 4: "rename", 5: "copy",
|
2014-04-10 14:20:58 -04:00
|
|
|
}
|
|
|
|
return diffTypes[diffType]
|
|
|
|
}
|
|
|
|
|
2016-11-25 01:23:48 -05:00
|
|
|
// DiffLineTypeToStr returns diff line type name
|
2014-04-10 14:20:58 -04:00
|
|
|
func DiffLineTypeToStr(diffType int) string {
|
|
|
|
switch diffType {
|
|
|
|
case 2:
|
|
|
|
return "add"
|
|
|
|
case 3:
|
|
|
|
return "del"
|
|
|
|
case 4:
|
|
|
|
return "tag"
|
|
|
|
}
|
|
|
|
return "same"
|
|
|
|
}
|
2017-10-14 19:17:39 -04:00
|
|
|
|
2021-09-18 12:22:51 -04:00
|
|
|
// MigrationIcon returns a SVG name matching the service an issue/comment was migrated from
|
2019-07-07 22:14:12 -04:00
|
|
|
func MigrationIcon(hostname string) string {
|
|
|
|
switch hostname {
|
|
|
|
case "github.com":
|
2021-09-18 12:22:51 -04:00
|
|
|
return "octicon-mark-github"
|
2019-07-07 22:14:12 -04:00
|
|
|
default:
|
2021-09-18 12:22:51 -04:00
|
|
|
return "gitea-git"
|
2019-07-07 22:14:12 -04:00
|
|
|
}
|
|
|
|
}
|
2019-11-07 08:34:28 -05:00
|
|
|
|
|
|
|
func buildSubjectBodyTemplate(stpl *texttmpl.Template, btpl *template.Template, name string, content []byte) {
|
|
|
|
// Split template into subject and body
|
|
|
|
var subjectContent []byte
|
|
|
|
bodyContent := content
|
|
|
|
loc := mailSubjectSplit.FindIndex(content)
|
|
|
|
if loc != nil {
|
|
|
|
subjectContent = content[0:loc[0]]
|
|
|
|
bodyContent = content[loc[1]:]
|
|
|
|
}
|
|
|
|
if _, err := stpl.New(name).
|
|
|
|
Parse(string(subjectContent)); err != nil {
|
|
|
|
log.Warn("Failed to parse template [%s/subject]: %v", name, err)
|
|
|
|
}
|
|
|
|
if _, err := btpl.New(name).
|
|
|
|
Parse(string(bodyContent)); err != nil {
|
|
|
|
log.Warn("Failed to parse template [%s/body]: %v", name, err)
|
|
|
|
}
|
|
|
|
}
|
2021-06-14 13:20:43 -04:00
|
|
|
|
|
|
|
type remoteAddress struct {
|
|
|
|
Address string
|
|
|
|
Username string
|
|
|
|
Password string
|
|
|
|
}
|
|
|
|
|
2022-08-14 23:12:01 -04:00
|
|
|
func mirrorRemoteAddress(ctx context.Context, m *repo_model.Repository, remoteName string, ignoreOriginalURL bool) remoteAddress {
|
2021-06-14 13:20:43 -04:00
|
|
|
a := remoteAddress{}
|
2022-06-11 09:50:14 -04:00
|
|
|
|
|
|
|
remoteURL := m.OriginalURL
|
2022-08-14 23:12:01 -04:00
|
|
|
if ignoreOriginalURL || remoteURL == "" {
|
2022-06-11 09:50:14 -04:00
|
|
|
var err error
|
|
|
|
remoteURL, err = git.GetRemoteAddress(ctx, m.RepoPath(), remoteName)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("GetRemoteURL %v", err)
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
}
|
2021-06-14 13:20:43 -04:00
|
|
|
|
2022-06-11 09:50:14 -04:00
|
|
|
u, err := giturl.Parse(remoteURL)
|
2021-06-14 13:20:43 -04:00
|
|
|
if err != nil {
|
2022-06-11 09:50:14 -04:00
|
|
|
log.Error("giturl.Parse %v", err)
|
2021-06-14 13:20:43 -04:00
|
|
|
return a
|
|
|
|
}
|
|
|
|
|
2022-06-11 09:50:14 -04:00
|
|
|
if u.Scheme != "ssh" && u.Scheme != "file" {
|
|
|
|
if u.User != nil {
|
|
|
|
a.Username = u.User.Username()
|
|
|
|
a.Password, _ = u.User.Password()
|
|
|
|
}
|
|
|
|
u.User = nil
|
2021-06-14 13:20:43 -04:00
|
|
|
}
|
|
|
|
a.Address = u.String()
|
|
|
|
|
|
|
|
return a
|
|
|
|
}
|
2022-06-12 08:08:23 -04:00
|
|
|
|
|
|
|
// JsPrettyNumber renders a number using english decimal separators, e.g. 1,200 and subsequent
|
|
|
|
// JS will replace the number with locale-specific separators, based on the user's selected language
|
|
|
|
func JsPrettyNumber(i interface{}) template.HTML {
|
|
|
|
num := util.NumberIntoInt64(i)
|
|
|
|
|
|
|
|
return template.HTML(`<span class="js-pretty-number" data-value="` + strconv.FormatInt(num, 10) + `">` + base.PrettyNumber(num) + `</span>`)
|
|
|
|
}
|