gitea-1120-rc1/routers/api/v1/repo/wiki.go

package repo

//
import (
	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/modules/context"
	"code.gitea.io/gitea/modules/markup/markdown"
	api "code.gitea.io/gitea/modules/structs"
	"code.gitea.io/gitea/modules/wikies"
	wiki_service "code.gitea.io/gitea/services/wiki"
	"net/http"
	"sort"

)

func WikiList(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() {
		ctx.CheckHasWiki()
		return
	}
	repository := ctx.Repo.Repository
	wikiCloneLink := repository.CloneWikiLink()
	wikiRepo, commit, err := wikies.FindWikiRepoCommit(ctx)
	if err != nil {
		if wikiRepo != nil {
			wikiRepo.Close()
		}
		return
	}
	entries, err := commit.ListEntries()
	if err != nil {
		if wikiRepo != nil {
			wikiRepo.Close()
		}
		return
	}
	wikiesList := make([]api.WikiesResponse, 0, len(entries))
	for _, entry := range entries {
		if !entry.IsRegular() {
			continue
		}
		c, err := wikiRepo.GetCommitByPath(entry.Name())
		if err != nil {
			if wikiRepo != nil {
				wikiRepo.Close()
			}
			ctx.ServerError("GetCommit", err)
			return
		}
		wikiName, err := wiki_service.FilenameToName(entry.Name())
		if err != nil {
			if models.IsErrWikiInvalidFileName(err) {
				continue
			}
			if wikiRepo != nil {
				wikiRepo.Close()
			}
			ctx.ServerError("WikiFilenameToName", err)
			return
		}
		wikiesList = append(wikiesList, api.WikiesResponse{
			When:  c.Author.When.Unix(),
			WikiCloneLink: api.CloneLink{
				HTTPS: wikiCloneLink.HTTPS,
				SSH:   wikiCloneLink.SSH,
			},
			WikiMeta: api.WikiMeta{
				Name: wikiName,
				Commit: api.WikiCommit{
					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.Committer.When.Unix(),
					},
					ID:      c.ID.String(),
					Message: c.Message(),
				},
			},
		})
	}

	//根据创建时间，按最新的时间排序
	sort.Slice(wikiesList, func(i, j int) bool {
		return wikiesList[i].Commit.Commiter.When < wikiesList[j].Commit.Commiter.When
	})
	ctx.JSON(http.StatusOK, wikiesList)
}

func GetWiki(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, _ := wikies.FindWikiRepoCommit(ctx)
	repository := ctx.Repo.Repository
	wikiCloneLink := repository.CloneWikiLink()
	pageName := wiki_service.NormalizeWikiName(ctx.Params(":page"))
	if len(pageName) == 0 {
		pageName = "Home"
	}
	data, entry, pageFilename, noEntry := wikies.WikiContentsByName(ctx, commit, pageName)
	if noEntry {
		ctx.NotFound()
		return
	}
	if entry == nil || ctx.Written() {
		if wikiRepo != nil {
			wikiRepo.Close()
		}
	}
	metas := ctx.Repo.Repository.ComposeDocumentMetas()
	PageContent := markdown.RenderWiki(data, ctx.Repo.RepoLink, metas)

	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: wikiCloneLink.HTTPS,
			SSH:   wikiCloneLink.SSH,
		},
		WikiMeta: api.WikiMeta{
			Name: pageName,
			Commit: api.WikiCommit{
				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: PageContent,
	}
	ctx.JSON(http.StatusOK, wiki)
}

func CreateWiki(ctx *context.APIContext, form api.WikiOption) {
	// 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"

	err1 := wiki_service.CheckFile(form.Name)
	if err1 != nil {
		ctx.FileNameError()
		return
	}
	OwnerName := ctx.Repo.Repository.OwnerName
	RepoName := ctx.Repo.Repository.Name
	repository := ctx.Repo.Repository
	wikiCloneLink := repository.CloneWikiLink()
	wikies.NewWikiPost(ctx, form)
	wikiRepo, commit, _ := wikies.FindWikiRepoCommit(ctx)
	data, entry, pageFilename, _ := wikies.WikiContentsByName(ctx, commit, form.Name)
	metas := ctx.Repo.Repository.ComposeDocumentMetas()
	PageContent := markdown.RenderWiki(data, ctx.Repo.RepoLink, metas)
	commitsCount, _ := wikiRepo.FileCommitsCount("master", pageFilename)
	c, err := wikiRepo.GetCommitByPath(entry.Name())
	if err != nil {
		if models.IsErrWikiInvalidFileName(err) {
			return
		}
	}
	wiki := api.WikiResponse{
		OwnerName: OwnerName,
		RepoName: RepoName,
		WikiCloneLink: api.CloneLink{
			HTTPS: wikiCloneLink.HTTPS,
			SSH:   wikiCloneLink.SSH,
		},
		WikiMeta: api.WikiMeta{
			Name: form.Name,
			Commit: api.WikiCommit{
				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: PageContent,
	}
	ctx.JSON(http.StatusOK, wiki)
}

func EditWiki(ctx *context.APIContext, form api.WikiOption) {
	// 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"

	newWikiName := wiki_service.NormalizeWikiName(form.Name)
	err1 := wiki_service.CheckFile(newWikiName)
	if err1 != nil {
		ctx.FileNameError()
		return
	}

	wikies.EditWikiPost(ctx, form)

	OwnerName := ctx.Repo.Repository.OwnerName
	RepoName := ctx.Repo.Repository.Name

	wikiRepo, commit, _ := wikies.FindWikiRepoCommit(ctx)
	data, entry, pageFilename, _ := wikies.WikiContentsByName(ctx, commit, form.Name) //
	metas := ctx.Repo.Repository.ComposeDocumentMetas()
	PageContent := markdown.RenderWiki(data, ctx.Repo.RepoLink, metas)
	commitsCount, _ := wikiRepo.FileCommitsCount("master", pageFilename)
	c, err := wikiRepo.GetCommitByPath(entry.Name())
	if err != nil {
		if models.IsErrWikiInvalidFileName(err) {
			return
		}
	}
	wiki := api.WikiResponse{
		OwnerName: OwnerName,
		RepoName: RepoName,
		WikiMeta: api.WikiMeta{
			Name: form.Name,
			Commit: api.WikiCommit{
				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: PageContent,
	}
	ctx.JSON(http.StatusOK, wiki)
}
func DeleteWiki(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
	}
}