1033 lines
26 KiB
Go
1033 lines
26 KiB
Go
package repo
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"sort"
|
|
"strings"
|
|
|
|
"code.gitea.io/gitea/models"
|
|
"code.gitea.io/gitea/modules/context"
|
|
"code.gitea.io/gitea/modules/convert"
|
|
"code.gitea.io/gitea/modules/git"
|
|
"code.gitea.io/gitea/modules/markup"
|
|
"code.gitea.io/gitea/modules/markup/markdown"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
api "code.gitea.io/gitea/modules/structs"
|
|
"code.gitea.io/gitea/modules/util"
|
|
"code.gitea.io/gitea/modules/web"
|
|
webWiki "code.gitea.io/gitea/routers/web/repo"
|
|
"github.com/russross/blackfriday/v2"
|
|
|
|
wiki_service "code.gitea.io/gitea/services/wiki"
|
|
)
|
|
|
|
// NewWikiPage response for wiki create request
|
|
func NewWikiPage(ctx *context.APIContext) {
|
|
// swagger:operation POST /repos/{owner}/{repo}/wiki/new repository repoCreateWikiPage
|
|
// ---
|
|
// summary: Create a wiki page
|
|
// consumes:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: body
|
|
// in: body
|
|
// schema:
|
|
// "$ref": "#/definitions/CreateWikiPageOptions"
|
|
// responses:
|
|
// "201":
|
|
// "$ref": "#/responses/WikiPage"
|
|
// "400":
|
|
// "$ref": "#/responses/error"
|
|
// "403":
|
|
// "$ref": "#/responses/forbidden"
|
|
|
|
form := web.GetForm(ctx).(*api.CreateWikiPageOptions)
|
|
|
|
if util.IsEmptyString(form.Title) {
|
|
ctx.Error(http.StatusBadRequest, "emptyTitle", nil)
|
|
return
|
|
}
|
|
|
|
wikiName := wiki_service.NormalizeWikiName(form.Title)
|
|
|
|
if len(form.Message) == 0 {
|
|
form.Message = fmt.Sprintf("Add '%s'", form.Title)
|
|
}
|
|
|
|
content, err := base64.StdEncoding.DecodeString(form.ContentBase64)
|
|
if err != nil {
|
|
ctx.Error(http.StatusBadRequest, "invalid base64 encoding of content", err)
|
|
return
|
|
}
|
|
form.ContentBase64 = string(content)
|
|
|
|
if err := wiki_service.AddWikiPage(ctx.User, ctx.Repo.Repository, wikiName, form.ContentBase64, form.Message); err != nil {
|
|
if models.IsErrWikiReservedName(err) {
|
|
ctx.Error(http.StatusBadRequest, "IsErrWikiReservedName", err)
|
|
} else if models.IsErrWikiAlreadyExist(err) {
|
|
ctx.Error(http.StatusBadRequest, "IsErrWikiAlreadyExists", err)
|
|
} else {
|
|
ctx.Error(http.StatusInternalServerError, "AddWikiPage", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
wikiPage := getWikiPage(ctx, wikiName)
|
|
if !ctx.Written() {
|
|
ctx.JSON(http.StatusCreated, wikiPage)
|
|
}
|
|
}
|
|
|
|
// EditWikiPage response for wiki modify request
|
|
func EditWikiPage(ctx *context.APIContext) {
|
|
// swagger:operation PATCH /repos/{owner}/{repo}/wiki/page/{pageName} repository repoEditWikiPage
|
|
// ---
|
|
// summary: Edit a wiki page
|
|
// consumes:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: pageName
|
|
// in: path
|
|
// description: name of the page
|
|
// type: string
|
|
// required: true
|
|
// - name: body
|
|
// in: body
|
|
// schema:
|
|
// "$ref": "#/definitions/CreateWikiPageOptions"
|
|
// responses:
|
|
// "200":
|
|
// "$ref": "#/responses/WikiPage"
|
|
// "400":
|
|
// "$ref": "#/responses/error"
|
|
// "403":
|
|
// "$ref": "#/responses/forbidden"
|
|
form := web.GetForm(ctx).(*api.CreateWikiPageOptions)
|
|
|
|
oldWikiName := wiki_service.NormalizeWikiName(ctx.Params(":pageName"))
|
|
newWikiName := wiki_service.NormalizeWikiName(form.Title)
|
|
|
|
if len(newWikiName) == 0 {
|
|
newWikiName = oldWikiName
|
|
}
|
|
|
|
if len(form.Message) == 0 {
|
|
form.Message = fmt.Sprintf("Update '%s'", newWikiName)
|
|
}
|
|
|
|
content, err := base64.RawStdEncoding.DecodeString(form.ContentBase64)
|
|
if err != nil {
|
|
ctx.Error(http.StatusBadRequest, "invalid base64 encoding of content", err)
|
|
return
|
|
}
|
|
form.ContentBase64 = string(content)
|
|
|
|
if err := wiki_service.EditWikiPage(ctx.User, ctx.Repo.Repository, oldWikiName, newWikiName, form.ContentBase64, form.Message); err != nil {
|
|
ctx.Error(http.StatusInternalServerError, "EditWikiPage", err)
|
|
return
|
|
}
|
|
|
|
wikiPage := getWikiPage(ctx, newWikiName)
|
|
|
|
if !ctx.Written() {
|
|
ctx.JSON(http.StatusOK, wikiPage)
|
|
}
|
|
}
|
|
|
|
func getWikiPage(ctx *context.APIContext, title string) *api.WikiPage {
|
|
title = wiki_service.NormalizeWikiName(title)
|
|
|
|
wikiRepo, commit := findWikiRepoCommit(ctx)
|
|
if wikiRepo != nil {
|
|
defer wikiRepo.Close()
|
|
}
|
|
if ctx.Written() {
|
|
return nil
|
|
}
|
|
|
|
// lookup filename in wiki - get filecontent, real filename
|
|
content, pageFilename := wikiContentsByName(ctx, commit, title, false)
|
|
if ctx.Written() {
|
|
return nil
|
|
}
|
|
|
|
sidebarContent, _ := wikiContentsByName(ctx, commit, "_Sidebar", true)
|
|
if ctx.Written() {
|
|
return nil
|
|
}
|
|
|
|
footerContent, _ := wikiContentsByName(ctx, commit, "_Footer", true)
|
|
if ctx.Written() {
|
|
return nil
|
|
}
|
|
|
|
// get commit count - wiki revisions
|
|
commitsCount, _ := wikiRepo.FileCommitsCount("master", pageFilename)
|
|
|
|
// Get last change information
|
|
lastCommit, err := wikiRepo.GetCommitByPath(pageFilename)
|
|
if err != nil {
|
|
ctx.Error(http.StatusInternalServerError, "GetCommitByPath", err)
|
|
return nil
|
|
}
|
|
|
|
return &api.WikiPage{
|
|
WikiPageMetaData: convert.ToWikiPageMetaData(title, lastCommit, ctx.Repo.Repository),
|
|
ContentBase64: content,
|
|
CommitCount: commitsCount,
|
|
Sidebar: sidebarContent,
|
|
Footer: footerContent,
|
|
}
|
|
}
|
|
|
|
// DeleteWikiPage delete wiki page
|
|
func DeleteWikiPage(ctx *context.APIContext) {
|
|
// swagger:operation DELETE /repos/{owner}/{repo}/wiki/page/{pageName} repository repoDeleteWikiPage
|
|
// ---
|
|
// summary: Delete a wiki page
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: pageName
|
|
// in: path
|
|
// description: name of the page
|
|
// type: string
|
|
// required: true
|
|
// responses:
|
|
// "204":
|
|
// "$ref": "#/responses/empty"
|
|
// "403":
|
|
// "$ref": "#/responses/forbidden"
|
|
// "404":
|
|
// "$ref": "#/responses/notFound"
|
|
|
|
wikiName := wiki_service.NormalizeWikiName(ctx.Params(":pageName"))
|
|
|
|
if err := wiki_service.DeleteWikiPage(ctx.User, ctx.Repo.Repository, wikiName); err != nil {
|
|
if err.Error() == "file does not exist" {
|
|
ctx.NotFound(err)
|
|
return
|
|
}
|
|
ctx.Error(http.StatusInternalServerError, "DeleteWikiPage", err)
|
|
return
|
|
}
|
|
|
|
ctx.Status(http.StatusNoContent)
|
|
}
|
|
|
|
// ListWikiPages get wiki pages list
|
|
func ListWikiPages(ctx *context.APIContext) {
|
|
// swagger:operation GET /repos/{owner}/{repo}/wiki/pages repository repoGetWikiPages
|
|
// ---
|
|
// summary: Get all wiki pages
|
|
// produces:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: filepath
|
|
// in: query
|
|
// description: path of the file
|
|
// type: string
|
|
// required: false
|
|
// - name: page
|
|
// in: query
|
|
// description: page number of results to return (1-based)
|
|
// type: integer
|
|
// - name: limit
|
|
// in: query
|
|
// description: page size of results
|
|
// type: integer
|
|
// responses:
|
|
// "200":
|
|
// "$ref": "#/responses/WikiPageList"
|
|
// "404":
|
|
// "$ref": "#/responses/notFound"
|
|
|
|
wikiRepo, commit := findWikiRepoCommit(ctx)
|
|
if wikiRepo != nil {
|
|
defer wikiRepo.Close()
|
|
}
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
page := ctx.QueryInt("page")
|
|
if page <= 1 {
|
|
page = 1
|
|
}
|
|
limit := ctx.QueryInt("limit")
|
|
if limit <= 1 {
|
|
limit = setting.API.DefaultPagingNum
|
|
}
|
|
|
|
skip := (page - 1) * limit
|
|
max := page * limit
|
|
filePath := ctx.Query("filepath")
|
|
var entries []*git.TreeEntry
|
|
var err error
|
|
if filePath == "" {
|
|
entries, err = commit.ListEntries()
|
|
} else {
|
|
tree, subTreeErr := commit.SubTree(filePath)
|
|
if subTreeErr != nil {
|
|
ctx.ServerError("SubTree", err)
|
|
return
|
|
}
|
|
entries, err = tree.ListEntries()
|
|
}
|
|
if err != nil {
|
|
ctx.ServerError("ListEntries", err)
|
|
return
|
|
}
|
|
lists := make([]*api.WikiListMetaData, 0, len(entries))
|
|
for i, entry := range entries {
|
|
if i < skip || i >= max || (!entry.IsRegular() && !entry.IsDir()) {
|
|
continue
|
|
}
|
|
if entry.IsRegular() {
|
|
var commit *git.Commit
|
|
if filePath == "" {
|
|
commit, err = wikiRepo.GetCommitByPath(entry.Name())
|
|
} else {
|
|
commit, err = wikiRepo.GetCommitByPath(fmt.Sprintf("%s/%s", filePath, entry.Name()))
|
|
}
|
|
if err != nil {
|
|
ctx.Error(http.StatusInternalServerError, "GetCommit", err)
|
|
return
|
|
}
|
|
wikiName, err := wiki_service.FilenameToName(entry.Name())
|
|
if err != nil {
|
|
if models.IsErrWikiInvalidFileName(err) {
|
|
continue
|
|
}
|
|
ctx.Error(http.StatusInternalServerError, "WikiFilenameToName", err)
|
|
return
|
|
}
|
|
lists = append(lists, convert.RegularToWikiPageMetaData(wikiName, commit, ctx.Repo.Repository))
|
|
}
|
|
if entry.IsDir() {
|
|
var commit *git.Commit
|
|
if filePath == "" {
|
|
commit, err = wikiRepo.GetCommitByPath(entry.Name())
|
|
} else {
|
|
commit, err = wikiRepo.GetCommitByPath(fmt.Sprintf("%s/%s", filePath, entry.Name()))
|
|
}
|
|
if err != nil {
|
|
ctx.Error(http.StatusInternalServerError, "GetCommit", err)
|
|
return
|
|
}
|
|
lists = append(lists, convert.DirToWikiPageMetaData(entry.Name(), commit, ctx.Repo.Repository))
|
|
}
|
|
|
|
}
|
|
|
|
ctx.SetTotalCountHeader(int64(len(entries)))
|
|
ctx.JSON(http.StatusOK, lists)
|
|
}
|
|
|
|
// GetWikiPage get single wiki page
|
|
func GetWikiPage(ctx *context.APIContext) {
|
|
// swagger:operation GET /repos/{owner}/{repo}/wiki/page/{pageName} repository repoGetWikiPage
|
|
// ---
|
|
// summary: Get a wiki page
|
|
// produces:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: pageName
|
|
// in: path
|
|
// description: name of the page
|
|
// type: string
|
|
// required: true
|
|
// responses:
|
|
// "200":
|
|
// "$ref": "#/responses/WikiPage"
|
|
// "404":
|
|
// "$ref": "#/responses/notFound"
|
|
|
|
// get requested pagename
|
|
pageName := wiki_service.NormalizeWikiName(ctx.Params(":pageName"))
|
|
|
|
wikiPage := getWikiPage(ctx, pageName)
|
|
if !ctx.Written() {
|
|
ctx.JSON(http.StatusOK, wikiPage)
|
|
}
|
|
}
|
|
|
|
// ListPageRevisions renders file revision list of wiki page
|
|
func ListPageRevisions(ctx *context.APIContext) {
|
|
// swagger:operation GET /repos/{owner}/{repo}/wiki/revisions/{pageName} repository repoGetWikiPageRevisions
|
|
// ---
|
|
// summary: Get revisions of a wiki page
|
|
// produces:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: pageName
|
|
// in: path
|
|
// description: name of the page
|
|
// type: string
|
|
// required: true
|
|
// - name: page
|
|
// in: query
|
|
// description: page number of results to return (1-based)
|
|
// type: integer
|
|
// responses:
|
|
// "200":
|
|
// "$ref": "#/responses/WikiCommitList"
|
|
// "404":
|
|
// "$ref": "#/responses/notFound"
|
|
|
|
wikiRepo, commit := findWikiRepoCommit(ctx)
|
|
if wikiRepo != nil {
|
|
defer wikiRepo.Close()
|
|
}
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
// get requested pagename
|
|
pageName := wiki_service.NormalizeWikiName(ctx.Params(":pageName"))
|
|
if len(pageName) == 0 {
|
|
pageName = "Home"
|
|
}
|
|
|
|
// lookup filename in wiki - get filecontent, gitTree entry , real filename
|
|
_, pageFilename := wikiContentsByName(ctx, commit, pageName, false)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
// get commit count - wiki revisions
|
|
commitsCount, _ := wikiRepo.FileCommitsCount("master", pageFilename)
|
|
|
|
page := ctx.QueryInt("page")
|
|
if page <= 1 {
|
|
page = 1
|
|
}
|
|
|
|
// get Commit Count
|
|
commitsHistory, err := wikiRepo.NewCommitsByFileAndRangeNoFollow("master", pageFilename, page)
|
|
if err != nil {
|
|
ctx.Error(http.StatusInternalServerError, "CommitsByFileAndRangeNoFollow", err)
|
|
return
|
|
}
|
|
|
|
ctx.SetTotalCountHeader(commitsCount)
|
|
ctx.JSON(http.StatusOK, convert.ToWikiCommitList(commitsHistory, commitsCount))
|
|
}
|
|
|
|
// findEntryForFile finds the tree entry for a target filepath.
|
|
func findEntryForFile(commit *git.Commit, target string) (*git.TreeEntry, error) {
|
|
entry, err := commit.GetTreeEntryByPath(target)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if entry != nil {
|
|
return entry, nil
|
|
}
|
|
|
|
// Then the unescaped, shortest alternative
|
|
var unescapedTarget string
|
|
if unescapedTarget, err = url.QueryUnescape(target); err != nil {
|
|
return nil, err
|
|
}
|
|
return commit.GetTreeEntryByPath(unescapedTarget)
|
|
}
|
|
|
|
// findWikiRepoCommit opens the wiki repo and returns the latest commit, writing to context on error.
|
|
// The caller is responsible for closing the returned repo again
|
|
func findWikiRepoCommit(ctx *context.APIContext) (*git.Repository, *git.Commit) {
|
|
wikiRepo, err := git.OpenRepository(ctx.Repo.Repository.WikiPath())
|
|
if err != nil {
|
|
|
|
if git.IsErrNotExist(err) || err.Error() == "no such file or directory" {
|
|
ctx.NotFound(err)
|
|
} else {
|
|
ctx.Error(http.StatusInternalServerError, "OpenRepository", err)
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
commit, err := wikiRepo.GetBranchCommit("master")
|
|
if err != nil {
|
|
if git.IsErrNotExist(err) {
|
|
ctx.NotFound(err)
|
|
} else {
|
|
ctx.Error(http.StatusInternalServerError, "GetBranchCommit", err)
|
|
}
|
|
return wikiRepo, nil
|
|
}
|
|
return wikiRepo, commit
|
|
}
|
|
|
|
// wikiContentsByEntry returns the contents of the wiki page referenced by the
|
|
// given tree entry, encoded with base64. Writes to ctx if an error occurs.
|
|
func wikiContentsByEntry(ctx *context.APIContext, entry *git.TreeEntry) string {
|
|
blob := entry.Blob()
|
|
if blob.Size() > setting.API.DefaultMaxBlobSize {
|
|
return ""
|
|
}
|
|
content, err := blob.GetBlobContentBase64()
|
|
if err != nil {
|
|
ctx.Error(http.StatusInternalServerError, "GetBlobContentBase64", err)
|
|
return ""
|
|
}
|
|
return content
|
|
}
|
|
|
|
// wikiContentsByName returns the contents of a wiki page, along with a boolean
|
|
// indicating whether the page exists. Writes to ctx if an error occurs.
|
|
func wikiContentsByName(ctx *context.APIContext, commit *git.Commit, wikiName string, isSidebarOrFooter bool) (string, string) {
|
|
pageFilename := wiki_service.NameToFilename(wikiName)
|
|
entry, err := findEntryForFile(commit, pageFilename)
|
|
if err != nil {
|
|
if git.IsErrNotExist(err) {
|
|
if !isSidebarOrFooter {
|
|
ctx.NotFound()
|
|
}
|
|
} else {
|
|
ctx.ServerError("findEntryForFile", err)
|
|
}
|
|
return "", ""
|
|
}
|
|
return wikiContentsByEntry(ctx, entry), pageFilename
|
|
}
|
|
|
|
func OldListWikiPages(ctx *context.APIContext) {
|
|
// swagger:operation GET /repos/{owner}/{repo}/wikies repository repoWikiList
|
|
// ---
|
|
// summary: List the wikies in a repository
|
|
// produces:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// responses:
|
|
// "200":
|
|
// "$ref": "#/responses/WikiList"
|
|
|
|
if !ctx.Repo.Repository.HasWiki() {
|
|
return
|
|
}
|
|
|
|
wikiCloneWiki := ctx.Repo.Repository.WikiCloneLink()
|
|
wikiRepo, commit, err := webWiki.FindWikiRepoCommit(ctx.Context)
|
|
if err != nil {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
return
|
|
}
|
|
defer func() {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
}()
|
|
|
|
entries, err := commit.ListEntries()
|
|
if err != nil {
|
|
ctx.ServerError("entries", err)
|
|
return
|
|
}
|
|
|
|
pages := make([]api.WikiesResponse, 0, len(entries))
|
|
for _, entry := range entries {
|
|
if !entry.IsRegular() {
|
|
continue
|
|
}
|
|
lastCommit, firstCommit, _ := wikiRepo.GetFirstAndLastCommitByPath("master", entry.Name())
|
|
if err != nil {
|
|
ctx.ServerError("GetCommitByPath", err)
|
|
return
|
|
}
|
|
wikiName, err := wiki_service.FilenameToName(entry.Name())
|
|
if err != nil {
|
|
if models.IsErrWikiInvalidFileName(err) {
|
|
continue
|
|
}
|
|
ctx.ServerError("FilenameToName", err)
|
|
return
|
|
}
|
|
pages = append(pages, api.WikiesResponse{
|
|
WikiCloneLink: api.CloneLink{
|
|
HTTPS: wikiCloneWiki.HTTPS,
|
|
SSH: wikiCloneWiki.SSH,
|
|
},
|
|
WikiMeta: api.WikiMeta{
|
|
Name: wikiName,
|
|
Commit: api.OldWikiCommit{
|
|
Author: api.WikiUser{
|
|
Name: lastCommit.Author.Name,
|
|
Email: lastCommit.Author.Email,
|
|
When: lastCommit.Author.When.Unix(),
|
|
},
|
|
Commiter: api.WikiUser{
|
|
Name: lastCommit.Committer.Name,
|
|
Email: lastCommit.Committer.Email,
|
|
When: lastCommit.Author.When.Unix(),
|
|
},
|
|
ID: lastCommit.ID.String(),
|
|
Message: lastCommit.Message(),
|
|
},
|
|
FirstCommit: api.OldWikiCommit{
|
|
Author: api.WikiUser{
|
|
Name: firstCommit.Author.Name,
|
|
Email: firstCommit.Author.Email,
|
|
When: firstCommit.Author.When.Unix(),
|
|
},
|
|
Commiter: api.WikiUser{
|
|
Name: firstCommit.Committer.Name,
|
|
Email: firstCommit.Committer.Email,
|
|
When: firstCommit.Author.When.Unix(),
|
|
},
|
|
ID: firstCommit.ID.String(),
|
|
Message: firstCommit.Message(),
|
|
},
|
|
},
|
|
})
|
|
}
|
|
//sort by time
|
|
sort.Slice(pages, func(i, j int) bool {
|
|
return pages[i].FirstCommit.Author.When > pages[j].FirstCommit.Author.When
|
|
})
|
|
ctx.JSON(http.StatusOK, pages)
|
|
}
|
|
|
|
func OldCreateWiki(ctx *context.APIContext) {
|
|
// swagger:operation POST /repos/{owner}/{repo}/wikies repository repoCreateWiki
|
|
// ---
|
|
// summary: Create a wiki in a repository
|
|
// produces:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: body
|
|
// in: body
|
|
// schema:
|
|
// "$ref": "#/definitions/WikiOption"
|
|
// responses:
|
|
// "200":
|
|
// "$ref": "#/responses/Wiki"
|
|
|
|
form := web.GetForm(ctx).(*api.WikiOption)
|
|
|
|
err := wiki_service.CheckFile(form.Name)
|
|
if err != nil {
|
|
ctx.FileNameError()
|
|
return
|
|
}
|
|
|
|
wikiName := wiki_service.NormalizeWikiName(form.Name)
|
|
wikiCloneLink := ctx.Repo.Repository.WikiCloneLink()
|
|
|
|
if err := wiki_service.AddWikiPage(ctx.User, ctx.Repo.Repository, wikiName, form.Content, form.CommitMessage); err != nil {
|
|
|
|
if models.IsErrWikiReservedName(err) {
|
|
ctx.Error(http.StatusInternalServerError, "WikiNameIsReservedPage", "wiki名称是被保留的.")
|
|
} else if models.IsErrWikiAlreadyExist(err) {
|
|
ctx.Error(http.StatusConflict, "WikiNameAlreadyExist", "wiki名称已存在")
|
|
} else {
|
|
ctx.Error(http.StatusInternalServerError, "AddWikiPage", err)
|
|
}
|
|
return
|
|
}
|
|
wikiRepo, commit, _ := webWiki.FindWikiRepoCommit(ctx.Context)
|
|
defer func() {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
}()
|
|
data, entry, pageFilename, _ := webWiki.WikiContentsByName(ctx.Context, commit, form.Name)
|
|
metas := ctx.Repo.Repository.ComposeDocumentMetas()
|
|
|
|
var rctx = &markup.RenderContext{
|
|
URLPrefix: ctx.Repo.RepoLink,
|
|
Metas: metas,
|
|
IsWiki: true,
|
|
}
|
|
|
|
var buf strings.Builder
|
|
if err := markdown.Render(rctx, bytes.NewReader(data), &buf); err != nil {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
ctx.ServerError("Render", err)
|
|
return
|
|
}
|
|
|
|
commitsCount, _ := wikiRepo.FileCommitsCount("master", pageFilename)
|
|
c, err := wikiRepo.GetCommitByPath(entry.Name())
|
|
if err != nil {
|
|
if models.IsErrWikiInvalidFileName(err) {
|
|
return
|
|
}
|
|
}
|
|
wiki := api.WikiResponse{
|
|
WikiCloneLink: api.CloneLink{
|
|
HTTPS: wikiCloneLink.HTTPS,
|
|
SSH: wikiCloneLink.SSH,
|
|
},
|
|
WikiMeta: api.WikiMeta{
|
|
Name: form.Name,
|
|
Commit: api.OldWikiCommit{
|
|
Author: api.WikiUser{
|
|
Name: c.Author.Name,
|
|
Email: c.Author.Email,
|
|
When: c.Author.When.Unix(),
|
|
},
|
|
Commiter: api.WikiUser{
|
|
Name: c.Committer.Name,
|
|
Email: c.Committer.Email,
|
|
When: c.Author.When.Unix(),
|
|
},
|
|
ID: c.ID.String(),
|
|
Message: c.Message(),
|
|
},
|
|
},
|
|
CommitCounts: commitsCount,
|
|
MdContent: string(data),
|
|
SimpleContent: buf.String(),
|
|
}
|
|
ctx.JSON(http.StatusOK, wiki)
|
|
|
|
}
|
|
|
|
func OldGetWiki(ctx *context.APIContext) {
|
|
// swagger:operation GET /repos/{owner}/{repo}/wikies/{pagename} repository repoGetWiki
|
|
// ---
|
|
// summary: Get a Wiki
|
|
// produces:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: pagename
|
|
// in: path
|
|
// description: name of the wikipage
|
|
// type: string
|
|
// required: true
|
|
// responses:
|
|
// "200":
|
|
// "$ref": "#/responses/Wiki"
|
|
|
|
wikiRepo, commit, _ := webWiki.FindWikiRepoCommit(ctx.Context)
|
|
defer func() {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
}()
|
|
|
|
wikiCloneWiki := ctx.Repo.Repository.WikiCloneLink()
|
|
|
|
// pageName := wiki_service.NormalizeWikiName(ctx.Context.Params(":page"))
|
|
pageName := wiki_service.NormalizeWikiName(ctx.Params(":page"))
|
|
if len(pageName) == 0 {
|
|
pageName = "Home"
|
|
}
|
|
data, entry, pageFilename, noEntry := webWiki.WikiContentsByName(ctx.Context, commit, pageName)
|
|
if noEntry {
|
|
ctx.NotFound()
|
|
return
|
|
}
|
|
if entry == nil || ctx.Written() {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
}
|
|
metas := ctx.Repo.Repository.ComposeDocumentMetas()
|
|
|
|
var rctx = &markup.RenderContext{
|
|
URLPrefix: ctx.Repo.RepoLink,
|
|
Metas: metas,
|
|
IsWiki: true,
|
|
}
|
|
|
|
var buf strings.Builder
|
|
content := blackfriday.Run(data)
|
|
if err := markdown.Render(rctx, bytes.NewReader(data), &buf); err != nil {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
ctx.ServerError("Render", err)
|
|
return
|
|
}
|
|
c, err := wikiRepo.GetCommitByPath(entry.Name())
|
|
if err != nil {
|
|
if models.IsErrWikiInvalidFileName(err) {
|
|
return
|
|
}
|
|
}
|
|
commitsCount, _ := wikiRepo.FileCommitsCount("master", pageFilename)
|
|
wiki := api.WikiResponse{
|
|
WikiCloneLink: api.CloneLink{
|
|
HTTPS: wikiCloneWiki.HTTPS,
|
|
SSH: wikiCloneWiki.SSH,
|
|
},
|
|
WikiMeta: api.WikiMeta{
|
|
Name: pageName,
|
|
Commit: api.OldWikiCommit{
|
|
Author: api.WikiUser{
|
|
Name: c.Author.Name,
|
|
Email: c.Author.Email,
|
|
When: c.Author.When.Unix(),
|
|
},
|
|
Commiter: api.WikiUser{
|
|
Name: c.Committer.Name,
|
|
Email: c.Committer.Email,
|
|
When: c.Author.When.Unix(),
|
|
},
|
|
ID: c.ID.String(),
|
|
Message: c.Message(),
|
|
},
|
|
},
|
|
CommitCounts: commitsCount,
|
|
MdContent: string(data),
|
|
SimpleContent: string(content),
|
|
}
|
|
ctx.JSON(http.StatusOK, wiki)
|
|
}
|
|
|
|
func OldEditWiki(ctx *context.APIContext) {
|
|
// swagger:operation PATCH /repos/{owner}/{repo}/wikies/{pagename} repository repoEditWiki
|
|
// ---
|
|
// summary: Edit a wiki in a repository
|
|
// produces:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: pagename
|
|
// in: path
|
|
// description: name of the wiki
|
|
// type: string
|
|
// required: true
|
|
// - name: body
|
|
// in: body
|
|
// schema:
|
|
// "$ref": "#/definitions/WikiOption"
|
|
// responses:
|
|
// "201":
|
|
// "$ref": "#/responses/Wiki"
|
|
|
|
form := web.GetForm(ctx).(*api.WikiOption)
|
|
oldWikiName := wiki_service.NormalizeWikiName(ctx.Params(":page"))
|
|
newWikiName := wiki_service.NormalizeWikiName(form.Name)
|
|
err1 := wiki_service.CheckFile(newWikiName)
|
|
if err1 != nil {
|
|
ctx.FileNameError()
|
|
return
|
|
}
|
|
wikiRepo, commit, _ := webWiki.FindWikiRepoCommit(ctx.Context)
|
|
defer func() {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
}()
|
|
|
|
if _, _, _, noEntry := webWiki.WikiContentsByName(ctx.Context, commit, oldWikiName); noEntry {
|
|
ctx.Error(http.StatusNotFound, "WikiNotFound", "wiki不存在")
|
|
return
|
|
}
|
|
|
|
if _, _, _, noEntry := webWiki.WikiContentsByName(ctx.Context, commit, newWikiName); oldWikiName != newWikiName && !noEntry {
|
|
ctx.Error(http.StatusConflict, "WikiNameAlreadyExist", "wiki名称已存在")
|
|
return
|
|
}
|
|
|
|
if len(form.CommitMessage) == 0 {
|
|
form.CommitMessage = ctx.Tr("repo.editor.update", form.Name)
|
|
}
|
|
|
|
if err := wiki_service.EditWikiPage(ctx.User, ctx.Repo.Repository, oldWikiName, newWikiName, form.Content, form.CommitMessage); err != nil {
|
|
ctx.Error(http.StatusInternalServerError, "EditWikiPage", err)
|
|
return
|
|
}
|
|
wikiRepo, newCommit, _ := webWiki.FindWikiRepoCommit(ctx.Context)
|
|
defer func() {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
}()
|
|
data, entry, pageFilename, _ := webWiki.WikiContentsByName(ctx.Context, newCommit, newWikiName)
|
|
c, err := wikiRepo.GetCommitByPath(entry.Name())
|
|
if err != nil {
|
|
if models.IsErrWikiInvalidFileName(err) {
|
|
return
|
|
}
|
|
}
|
|
metas := ctx.Repo.Repository.ComposeDocumentMetas()
|
|
// PageContent := markdown.RenderWiki(data, ctx.Repo.RepoLink, metas)
|
|
|
|
var rctx = &markup.RenderContext{
|
|
URLPrefix: ctx.Repo.RepoLink,
|
|
Metas: metas,
|
|
IsWiki: true,
|
|
}
|
|
|
|
var buf strings.Builder
|
|
if err := markdown.Render(rctx, bytes.NewReader(data), &buf); err != nil {
|
|
if wikiRepo != nil {
|
|
wikiRepo.Close()
|
|
}
|
|
ctx.ServerError("Render", err)
|
|
return
|
|
}
|
|
commitsCount, _ := wikiRepo.FileCommitsCount("master", pageFilename)
|
|
|
|
wiki := api.WikiResponse{
|
|
WikiMeta: api.WikiMeta{
|
|
Name: form.Name,
|
|
Commit: api.OldWikiCommit{
|
|
Author: api.WikiUser{
|
|
Name: c.Author.Name,
|
|
Email: c.Author.Email,
|
|
When: c.Author.When.Unix(),
|
|
},
|
|
Commiter: api.WikiUser{
|
|
Name: c.Committer.Name,
|
|
Email: c.Committer.Email,
|
|
When: c.Author.When.Unix(),
|
|
},
|
|
ID: c.ID.String(),
|
|
Message: c.Message(),
|
|
},
|
|
},
|
|
CommitCounts: commitsCount,
|
|
MdContent: string(data),
|
|
SimpleContent: buf.String(),
|
|
}
|
|
ctx.JSON(http.StatusOK, wiki)
|
|
}
|
|
func OldDeleteWiki(ctx *context.APIContext) {
|
|
// swagger:operation DELETE /repos/{owner}/{repo}/wikies/{pagename} repository repoDeleteWiki
|
|
// ---
|
|
// summary: Delete a wiki in a repository
|
|
// produces:
|
|
// - application/json
|
|
// parameters:
|
|
// - name: owner
|
|
// in: path
|
|
// description: owner of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: repo
|
|
// in: path
|
|
// description: name of the repo
|
|
// type: string
|
|
// required: true
|
|
// - name: pagename
|
|
// in: path
|
|
// description: name of the wiki
|
|
// type: string
|
|
// required: true
|
|
// responses:
|
|
// "204":
|
|
// "$ref": "#/responses/empty"
|
|
// "500":
|
|
// "$ref": "#/responses/noFound"
|
|
|
|
wikiName := wiki_service.NormalizeWikiName(ctx.Params(":page"))
|
|
if len(wikiName) == 0 {
|
|
wikiName = "Home"
|
|
}
|
|
|
|
err2 := wiki_service.DeleteWikiPage(ctx.User, ctx.Repo.Repository, wikiName)
|
|
if err2 != nil {
|
|
ctx.FileExistError()
|
|
return
|
|
}
|
|
}
|