2014-08-26 12:11:15 +02:00
|
|
|
// Copyright 2014 The Gogs Authors. All rights reserved.
|
2018-11-28 12:26:14 +01:00
|
|
|
// Copyright 2018 The Gitea Authors. All rights reserved.
|
2022-11-27 19:20:29 +01:00
|
|
|
// SPDX-License-Identifier: MIT
|
2014-08-26 12:11:15 +02:00
|
|
|
|
2015-12-04 23:16:42 +01:00
|
|
|
package repo
|
2014-08-26 12:11:15 +02:00
|
|
|
|
|
|
|
import (
|
2017-08-17 03:31:34 +02:00
|
|
|
"fmt"
|
2017-10-26 23:16:13 +02:00
|
|
|
"net/http"
|
2023-09-07 11:37:47 +02:00
|
|
|
"slices"
|
2017-02-11 05:00:01 +01:00
|
|
|
"strings"
|
2021-01-03 00:47:47 +01:00
|
|
|
"time"
|
2014-08-26 12:11:15 +02:00
|
|
|
|
2024-04-01 15:48:14 +02:00
|
|
|
actions_model "code.gitea.io/gitea/models/actions"
|
2023-04-04 15:35:31 +02:00
|
|
|
activities_model "code.gitea.io/gitea/models/activities"
|
2021-11-24 10:49:20 +01:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2022-03-29 08:29:02 +02:00
|
|
|
"code.gitea.io/gitea/models/organization"
|
2021-11-28 12:58:28 +01:00
|
|
|
"code.gitea.io/gitea/models/perm"
|
2022-05-11 12:09:36 +02:00
|
|
|
access_model "code.gitea.io/gitea/models/perm/access"
|
2021-12-10 02:27:50 +01:00
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
2021-11-09 20:57:58 +01:00
|
|
|
unit_model "code.gitea.io/gitea/models/unit"
|
2021-11-24 10:49:20 +01:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2019-11-17 07:30:01 +01:00
|
|
|
"code.gitea.io/gitea/modules/git"
|
Simplify how git repositories are opened (#28937)
## Purpose
This is a refactor toward building an abstraction over managing git
repositories.
Afterwards, it does not matter anymore if they are stored on the local
disk or somewhere remote.
## What this PR changes
We used `git.OpenRepository` everywhere previously.
Now, we should split them into two distinct functions:
Firstly, there are temporary repositories which do not change:
```go
git.OpenRepository(ctx, diskPath)
```
Gitea managed repositories having a record in the database in the
`repository` table are moved into the new package `gitrepo`:
```go
gitrepo.OpenRepository(ctx, repo_model.Repo)
```
Why is `repo_model.Repository` the second parameter instead of file
path?
Because then we can easily adapt our repository storage strategy.
The repositories can be stored locally, however, they could just as well
be stored on a remote server.
## Further changes in other PRs
- A Git Command wrapper on package `gitrepo` could be created. i.e.
`NewCommand(ctx, repo_model.Repository, commands...)`. `git.RunOpts{Dir:
repo.RepoPath()}`, the directory should be empty before invoking this
method and it can be filled in the function only. #28940
- Remove the `RepoPath()`/`WikiPath()` functions to reduce the
possibility of mistakes.
---------
Co-authored-by: delvh <dev.lh@web.de>
2024-01-27 21:09:51 +01:00
|
|
|
"code.gitea.io/gitea/modules/gitrepo"
|
2023-03-02 00:44:23 +01:00
|
|
|
"code.gitea.io/gitea/modules/label"
|
2016-11-10 17:24:48 +01:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2024-02-29 19:52:49 +01:00
|
|
|
"code.gitea.io/gitea/modules/optional"
|
2022-04-22 19:19:55 +02:00
|
|
|
repo_module "code.gitea.io/gitea/modules/repository"
|
2016-11-10 17:24:48 +01:00
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2019-08-23 18:40:30 +02:00
|
|
|
api "code.gitea.io/gitea/modules/structs"
|
2019-10-02 11:30:41 +02:00
|
|
|
"code.gitea.io/gitea/modules/validation"
|
2021-01-26 16:36:53 +01:00
|
|
|
"code.gitea.io/gitea/modules/web"
|
2020-01-24 20:00:29 +01:00
|
|
|
"code.gitea.io/gitea/routers/api/v1/utils"
|
2024-04-01 15:48:14 +02:00
|
|
|
actions_service "code.gitea.io/gitea/services/actions"
|
2024-02-27 08:12:22 +01:00
|
|
|
"code.gitea.io/gitea/services/context"
|
2022-12-29 03:57:15 +01:00
|
|
|
"code.gitea.io/gitea/services/convert"
|
2023-05-09 01:30:14 +02:00
|
|
|
"code.gitea.io/gitea/services/issue"
|
2019-10-26 08:54:11 +02:00
|
|
|
repo_service "code.gitea.io/gitea/services/repository"
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 12:18:53 +01:00
|
|
|
wiki_service "code.gitea.io/gitea/services/wiki"
|
2014-08-26 12:11:15 +02:00
|
|
|
)
|
|
|
|
|
2016-11-24 08:04:31 +01:00
|
|
|
// Search repositories via options
|
2016-03-13 23:49:16 +01:00
|
|
|
func Search(ctx *context.APIContext) {
|
2017-11-13 08:02:25 +01:00
|
|
|
// swagger:operation GET /repos/search repository repoSearch
|
|
|
|
// ---
|
|
|
|
// summary: Search for repositories
|
|
|
|
// produces:
|
|
|
|
// - application/json
|
|
|
|
// parameters:
|
|
|
|
// - name: q
|
|
|
|
// in: query
|
|
|
|
// description: keyword
|
|
|
|
// type: string
|
2019-08-24 05:17:10 +02:00
|
|
|
// - name: topic
|
|
|
|
// in: query
|
|
|
|
// description: Limit search to repositories with keyword as topic
|
|
|
|
// type: boolean
|
2019-08-25 19:06:36 +02:00
|
|
|
// - name: includeDesc
|
|
|
|
// in: query
|
|
|
|
// description: include search of keyword within repository description
|
|
|
|
// type: boolean
|
2017-11-13 08:02:25 +01:00
|
|
|
// - name: uid
|
|
|
|
// in: query
|
2017-11-15 09:10:26 +01:00
|
|
|
// description: search only for repos that the user with the given id owns or contributes to
|
|
|
|
// type: integer
|
2018-10-21 05:40:42 +02:00
|
|
|
// format: int64
|
2019-11-11 16:15:29 +01:00
|
|
|
// - name: priority_owner_id
|
|
|
|
// in: query
|
|
|
|
// description: repo owner to prioritize in the results
|
|
|
|
// type: integer
|
|
|
|
// format: int64
|
2020-12-27 20:58:03 +01:00
|
|
|
// - name: team_id
|
|
|
|
// in: query
|
|
|
|
// description: search only for repos that belong to the given team id
|
|
|
|
// type: integer
|
|
|
|
// format: int64
|
2019-05-15 17:24:39 +02:00
|
|
|
// - name: starredBy
|
|
|
|
// in: query
|
|
|
|
// description: search only for repos that the user with the given id has starred
|
|
|
|
// type: integer
|
|
|
|
// format: int64
|
|
|
|
// - name: private
|
|
|
|
// in: query
|
|
|
|
// description: include private repositories this user has access to (defaults to true)
|
|
|
|
// type: boolean
|
2020-05-21 03:15:30 +02:00
|
|
|
// - name: is_private
|
2020-05-16 22:07:01 +02:00
|
|
|
// in: query
|
2020-05-21 03:15:30 +02:00
|
|
|
// description: show only pubic, private or all repositories (defaults to all)
|
2020-05-16 22:07:01 +02:00
|
|
|
// type: boolean
|
2019-11-11 16:15:29 +01:00
|
|
|
// - name: template
|
|
|
|
// in: query
|
|
|
|
// description: include template repositories this user has access to (defaults to true)
|
|
|
|
// type: boolean
|
2020-05-16 22:07:01 +02:00
|
|
|
// - name: archived
|
|
|
|
// in: query
|
|
|
|
// description: show only archived, non-archived or all repositories (defaults to all)
|
|
|
|
// type: boolean
|
2017-11-13 08:02:25 +01:00
|
|
|
// - name: mode
|
|
|
|
// in: query
|
|
|
|
// description: type of repository to search for. Supported values are
|
|
|
|
// "fork", "source", "mirror" and "collaborative"
|
|
|
|
// type: string
|
|
|
|
// - name: exclusive
|
|
|
|
// in: query
|
2017-11-15 09:10:26 +01:00
|
|
|
// description: if `uid` is given, search only for repos that the user owns
|
2017-11-13 08:02:25 +01:00
|
|
|
// type: boolean
|
2018-08-02 10:10:02 +02:00
|
|
|
// - name: sort
|
|
|
|
// in: query
|
|
|
|
// description: sort repos by attribute. Supported values are
|
|
|
|
// "alpha", "created", "updated", "size", and "id".
|
|
|
|
// Default is "alpha"
|
|
|
|
// type: string
|
|
|
|
// - name: order
|
|
|
|
// in: query
|
|
|
|
// description: sort order, either "asc" (ascending) or "desc" (descending).
|
|
|
|
// Default is "asc", ignored if "sort" is not specified.
|
|
|
|
// type: string
|
2020-01-24 20:00:29 +01:00
|
|
|
// - name: page
|
|
|
|
// in: query
|
|
|
|
// description: page number of results to return (1-based)
|
|
|
|
// type: integer
|
|
|
|
// - name: limit
|
|
|
|
// in: query
|
2020-06-09 06:57:38 +02:00
|
|
|
// description: page size of results
|
2020-01-24 20:00:29 +01:00
|
|
|
// type: integer
|
2017-11-13 08:02:25 +01:00
|
|
|
// responses:
|
|
|
|
// "200":
|
|
|
|
// "$ref": "#/responses/SearchResults"
|
|
|
|
// "422":
|
|
|
|
// "$ref": "#/responses/validationError"
|
2019-12-20 18:07:12 +01:00
|
|
|
|
2022-06-06 10:01:49 +02:00
|
|
|
opts := &repo_model.SearchRepoOptions{
|
2020-01-24 20:00:29 +01:00
|
|
|
ListOptions: utils.GetListOptions(ctx),
|
2022-03-22 08:03:22 +01:00
|
|
|
Actor: ctx.Doer,
|
2021-08-11 17:08:52 +02:00
|
|
|
Keyword: ctx.FormTrim("q"),
|
2021-07-29 03:42:15 +02:00
|
|
|
OwnerID: ctx.FormInt64("uid"),
|
|
|
|
PriorityOwnerID: ctx.FormInt64("priority_owner_id"),
|
|
|
|
TeamID: ctx.FormInt64("team_id"),
|
|
|
|
TopicOnly: ctx.FormBool("topic"),
|
2024-02-29 19:52:49 +01:00
|
|
|
Collaborate: optional.None[bool](),
|
2021-08-11 02:31:13 +02:00
|
|
|
Private: ctx.IsSigned && (ctx.FormString("private") == "" || ctx.FormBool("private")),
|
2024-02-29 19:52:49 +01:00
|
|
|
Template: optional.None[bool](),
|
2021-07-29 03:42:15 +02:00
|
|
|
StarredByID: ctx.FormInt64("starredBy"),
|
|
|
|
IncludeDescription: ctx.FormBool("includeDesc"),
|
2017-10-26 23:16:13 +02:00
|
|
|
}
|
|
|
|
|
2021-08-11 02:31:13 +02:00
|
|
|
if ctx.FormString("template") != "" {
|
2024-02-29 19:52:49 +01:00
|
|
|
opts.Template = optional.Some(ctx.FormBool("template"))
|
2019-11-11 16:15:29 +01:00
|
|
|
}
|
|
|
|
|
2021-07-29 03:42:15 +02:00
|
|
|
if ctx.FormBool("exclusive") {
|
2024-02-29 19:52:49 +01:00
|
|
|
opts.Collaborate = optional.Some(false)
|
2017-10-26 23:16:13 +02:00
|
|
|
}
|
|
|
|
|
2022-01-20 18:46:10 +01:00
|
|
|
mode := ctx.FormString("mode")
|
2017-10-26 23:16:13 +02:00
|
|
|
switch mode {
|
|
|
|
case "source":
|
2024-02-29 19:52:49 +01:00
|
|
|
opts.Fork = optional.Some(false)
|
|
|
|
opts.Mirror = optional.Some(false)
|
2017-10-26 23:16:13 +02:00
|
|
|
case "fork":
|
2024-02-29 19:52:49 +01:00
|
|
|
opts.Fork = optional.Some(true)
|
2017-10-26 23:16:13 +02:00
|
|
|
case "mirror":
|
2024-02-29 19:52:49 +01:00
|
|
|
opts.Mirror = optional.Some(true)
|
2017-10-26 23:16:13 +02:00
|
|
|
case "collaborative":
|
2024-02-29 19:52:49 +01:00
|
|
|
opts.Mirror = optional.Some(false)
|
|
|
|
opts.Collaborate = optional.Some(true)
|
2017-10-26 23:16:13 +02:00
|
|
|
case "":
|
|
|
|
default:
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", fmt.Errorf("Invalid search mode: \"%s\"", mode))
|
|
|
|
return
|
2014-08-26 12:11:15 +02:00
|
|
|
}
|
|
|
|
|
2021-08-11 02:31:13 +02:00
|
|
|
if ctx.FormString("archived") != "" {
|
2024-02-29 19:52:49 +01:00
|
|
|
opts.Archived = optional.Some(ctx.FormBool("archived"))
|
2020-05-16 22:07:01 +02:00
|
|
|
}
|
|
|
|
|
2021-08-11 02:31:13 +02:00
|
|
|
if ctx.FormString("is_private") != "" {
|
2024-02-29 19:52:49 +01:00
|
|
|
opts.IsPrivate = optional.Some(ctx.FormBool("is_private"))
|
2020-05-21 03:15:30 +02:00
|
|
|
}
|
|
|
|
|
2022-01-20 18:46:10 +01:00
|
|
|
sortMode := ctx.FormString("sort")
|
2018-08-02 10:10:02 +02:00
|
|
|
if len(sortMode) > 0 {
|
2022-01-20 18:46:10 +01:00
|
|
|
sortOrder := ctx.FormString("order")
|
2018-08-02 10:10:02 +02:00
|
|
|
if len(sortOrder) == 0 {
|
|
|
|
sortOrder = "asc"
|
|
|
|
}
|
2023-05-08 11:36:54 +02:00
|
|
|
if searchModeMap, ok := repo_model.SearchOrderByMap[sortOrder]; ok {
|
2018-08-02 10:10:02 +02:00
|
|
|
if orderBy, ok := searchModeMap[sortMode]; ok {
|
|
|
|
opts.OrderBy = orderBy
|
|
|
|
} else {
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", fmt.Errorf("Invalid sort mode: \"%s\"", sortMode))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", fmt.Errorf("Invalid sort order: \"%s\"", sortOrder))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-26 23:16:13 +02:00
|
|
|
var err error
|
2022-11-19 09:12:33 +01:00
|
|
|
repos, count, err := repo_model.SearchRepository(ctx, opts)
|
2014-08-26 12:11:15 +02:00
|
|
|
if err != nil {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.JSON(http.StatusInternalServerError, api.SearchError{
|
2017-05-02 15:35:59 +02:00
|
|
|
OK: false,
|
|
|
|
Error: err.Error(),
|
2014-08-26 12:11:15 +02:00
|
|
|
})
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-11-14 23:11:30 +01:00
|
|
|
results := make([]*api.Repository, len(repos))
|
2017-02-10 02:30:26 +01:00
|
|
|
for i, repo := range repos {
|
2023-02-18 13:11:03 +01:00
|
|
|
if err = repo.LoadOwner(ctx); err != nil {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.JSON(http.StatusInternalServerError, api.SearchError{
|
2017-05-02 15:35:59 +02:00
|
|
|
OK: false,
|
|
|
|
Error: err.Error(),
|
2014-08-26 12:11:15 +02:00
|
|
|
})
|
|
|
|
return
|
|
|
|
}
|
2023-06-22 15:08:08 +02:00
|
|
|
permission, err := access_model.GetUserRepoPermission(ctx, repo, ctx.Doer)
|
2017-02-10 02:30:26 +01:00
|
|
|
if err != nil {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.JSON(http.StatusInternalServerError, api.SearchError{
|
2017-05-02 15:35:59 +02:00
|
|
|
OK: false,
|
|
|
|
Error: err.Error(),
|
2017-02-10 02:30:26 +01:00
|
|
|
})
|
2014-08-26 12:11:15 +02:00
|
|
|
}
|
2023-06-22 15:08:08 +02:00
|
|
|
results[i] = convert.ToRepo(ctx, repo, permission)
|
2014-08-26 12:11:15 +02:00
|
|
|
}
|
2020-01-24 20:00:29 +01:00
|
|
|
ctx.SetLinkHeader(int(count), opts.PageSize)
|
2021-08-12 14:43:08 +02:00
|
|
|
ctx.SetTotalCountHeader(count)
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.JSON(http.StatusOK, api.SearchResults{
|
2017-05-02 15:35:59 +02:00
|
|
|
OK: true,
|
|
|
|
Data: results,
|
2014-08-26 12:11:15 +02:00
|
|
|
})
|
|
|
|
}
|
2014-08-29 05:24:37 +02:00
|
|
|
|
2016-11-24 08:04:31 +01:00
|
|
|
// CreateUserRepo create a repository for a user
|
2021-11-24 10:49:20 +01:00
|
|
|
func CreateUserRepo(ctx *context.APIContext, owner *user_model.User, opt api.CreateRepoOption) {
|
2019-02-21 23:07:58 +01:00
|
|
|
if opt.AutoInit && opt.Readme == "" {
|
|
|
|
opt.Readme = "Default"
|
|
|
|
}
|
2023-03-13 22:55:30 +01:00
|
|
|
|
|
|
|
// If the readme template does not exist, a 400 will be returned.
|
2023-09-07 11:37:47 +02:00
|
|
|
if opt.AutoInit && len(opt.Readme) > 0 && !slices.Contains(repo_module.Readmes, opt.Readme) {
|
2023-03-13 22:55:30 +01:00
|
|
|
ctx.Error(http.StatusBadRequest, "", fmt.Errorf("readme template does not exist, available templates: %v", repo_module.Readmes))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-09-06 14:08:51 +02:00
|
|
|
repo, err := repo_service.CreateRepository(ctx, ctx.Doer, owner, repo_service.CreateRepoOptions{
|
2023-12-17 12:56:08 +01:00
|
|
|
Name: opt.Name,
|
|
|
|
Description: opt.Description,
|
|
|
|
IssueLabels: opt.IssueLabels,
|
|
|
|
Gitignores: opt.Gitignores,
|
|
|
|
License: opt.License,
|
|
|
|
Readme: opt.Readme,
|
|
|
|
IsPrivate: opt.Private,
|
|
|
|
AutoInit: opt.AutoInit,
|
|
|
|
DefaultBranch: opt.DefaultBranch,
|
|
|
|
TrustModel: repo_model.ToTrustModel(opt.TrustModel),
|
|
|
|
IsTemplate: opt.Template,
|
2024-01-19 17:05:02 +01:00
|
|
|
ObjectFormatName: opt.ObjectFormatName,
|
2015-08-28 12:33:09 +02:00
|
|
|
})
|
2014-12-13 02:30:32 +01:00
|
|
|
if err != nil {
|
2021-12-12 16:48:20 +01:00
|
|
|
if repo_model.IsErrRepoAlreadyExist(err) {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusConflict, "", "The repository with the same name already exists.")
|
2021-11-24 10:49:20 +01:00
|
|
|
} else if db.IsErrNameReserved(err) ||
|
2022-04-22 19:19:55 +02:00
|
|
|
db.IsErrNamePatternNotAllowed(err) ||
|
2023-03-02 00:44:23 +01:00
|
|
|
label.IsErrTemplateLoad(err) {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", err)
|
2014-12-13 02:30:32 +01:00
|
|
|
} else {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusInternalServerError, "CreateRepository", err)
|
2014-12-13 02:30:32 +01:00
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-09-16 00:42:19 +02:00
|
|
|
// reload repo from db to get a real state after creation
|
2022-12-03 03:48:26 +01:00
|
|
|
repo, err = repo_model.GetRepositoryByID(ctx, repo.ID)
|
2020-09-16 00:42:19 +02:00
|
|
|
if err != nil {
|
|
|
|
ctx.Error(http.StatusInternalServerError, "GetRepositoryByID", err)
|
|
|
|
}
|
|
|
|
|
2023-06-22 15:08:08 +02:00
|
|
|
ctx.JSON(http.StatusCreated, convert.ToRepo(ctx, repo, access_model.Permission{AccessMode: perm.AccessModeOwner}))
|
2014-12-13 02:30:32 +01:00
|
|
|
}
|
|
|
|
|
2016-10-07 19:17:27 +02:00
|
|
|
// Create one repository of mine
|
2021-01-26 16:36:53 +01:00
|
|
|
func Create(ctx *context.APIContext) {
|
2017-11-13 08:02:25 +01:00
|
|
|
// swagger:operation POST /user/repos repository user createCurrentUserRepo
|
|
|
|
// ---
|
|
|
|
// summary: Create a repository
|
|
|
|
// consumes:
|
|
|
|
// - application/json
|
|
|
|
// produces:
|
|
|
|
// - application/json
|
|
|
|
// parameters:
|
|
|
|
// - name: body
|
|
|
|
// in: body
|
|
|
|
// schema:
|
|
|
|
// "$ref": "#/definitions/CreateRepoOption"
|
|
|
|
// responses:
|
|
|
|
// "201":
|
|
|
|
// "$ref": "#/responses/Repository"
|
2023-03-13 22:55:30 +01:00
|
|
|
// "400":
|
|
|
|
// "$ref": "#/responses/error"
|
2019-05-30 17:09:05 +02:00
|
|
|
// "409":
|
|
|
|
// description: The repository with the same name already exists.
|
|
|
|
// "422":
|
|
|
|
// "$ref": "#/responses/validationError"
|
2021-01-26 16:36:53 +01:00
|
|
|
opt := web.GetForm(ctx).(*api.CreateRepoOption)
|
2022-03-22 08:03:22 +01:00
|
|
|
if ctx.Doer.IsOrganization() {
|
2017-11-13 08:02:25 +01:00
|
|
|
// Shouldn't reach this condition, but just in case.
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", "not allowed creating repository for organization")
|
2014-12-13 02:30:32 +01:00
|
|
|
return
|
|
|
|
}
|
2022-03-22 08:03:22 +01:00
|
|
|
CreateUserRepo(ctx, ctx.Doer, *opt)
|
2014-12-13 02:30:32 +01:00
|
|
|
}
|
|
|
|
|
2021-07-05 17:29:08 +02:00
|
|
|
// Generate Create a repository using a template
|
|
|
|
func Generate(ctx *context.APIContext) {
|
|
|
|
// swagger:operation POST /repos/{template_owner}/{template_repo}/generate repository generateRepo
|
|
|
|
// ---
|
|
|
|
// summary: Create a repository using a template
|
|
|
|
// consumes:
|
|
|
|
// - application/json
|
|
|
|
// produces:
|
|
|
|
// - application/json
|
|
|
|
// parameters:
|
|
|
|
// - name: template_owner
|
|
|
|
// in: path
|
|
|
|
// description: name of the template repository owner
|
|
|
|
// type: string
|
|
|
|
// required: true
|
|
|
|
// - name: template_repo
|
|
|
|
// in: path
|
|
|
|
// description: name of the template repository
|
|
|
|
// type: string
|
|
|
|
// required: true
|
|
|
|
// - name: body
|
|
|
|
// in: body
|
|
|
|
// schema:
|
|
|
|
// "$ref": "#/definitions/GenerateRepoOption"
|
|
|
|
// responses:
|
|
|
|
// "201":
|
|
|
|
// "$ref": "#/responses/Repository"
|
|
|
|
// "403":
|
|
|
|
// "$ref": "#/responses/forbidden"
|
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
|
|
|
// "409":
|
|
|
|
// description: The repository with the same name already exists.
|
|
|
|
// "422":
|
|
|
|
// "$ref": "#/responses/validationError"
|
|
|
|
form := web.GetForm(ctx).(*api.GenerateRepoOption)
|
|
|
|
|
|
|
|
if !ctx.Repo.Repository.IsTemplate {
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", "this is not a template repo")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:03:22 +01:00
|
|
|
if ctx.Doer.IsOrganization() {
|
2021-07-05 17:29:08 +02:00
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", "not allowed creating repository for organization")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-02-28 14:40:36 +01:00
|
|
|
opts := repo_service.GenerateRepoOptions{
|
2023-07-21 06:32:47 +02:00
|
|
|
Name: form.Name,
|
|
|
|
DefaultBranch: form.DefaultBranch,
|
|
|
|
Description: form.Description,
|
|
|
|
Private: form.Private,
|
|
|
|
GitContent: form.GitContent,
|
|
|
|
Topics: form.Topics,
|
|
|
|
GitHooks: form.GitHooks,
|
|
|
|
Webhooks: form.Webhooks,
|
|
|
|
Avatar: form.Avatar,
|
|
|
|
IssueLabels: form.Labels,
|
|
|
|
ProtectedBranch: form.ProtectedBranch,
|
2021-07-05 17:29:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if !opts.IsValid() {
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", "must select at least one template item")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:03:22 +01:00
|
|
|
ctxUser := ctx.Doer
|
2021-07-05 17:29:08 +02:00
|
|
|
var err error
|
|
|
|
if form.Owner != ctxUser.Name {
|
2022-05-20 16:08:52 +02:00
|
|
|
ctxUser, err = user_model.GetUserByName(ctx, form.Owner)
|
2021-07-05 17:29:08 +02:00
|
|
|
if err != nil {
|
2021-11-24 10:49:20 +01:00
|
|
|
if user_model.IsErrUserNotExist(err) {
|
2023-07-04 20:36:08 +02:00
|
|
|
ctx.JSON(http.StatusNotFound, map[string]any{
|
2021-07-15 20:19:39 +02:00
|
|
|
"error": "request owner `" + form.Owner + "` does not exist",
|
2021-07-05 17:29:08 +02:00
|
|
|
})
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-07-15 20:19:39 +02:00
|
|
|
ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:03:22 +01:00
|
|
|
if !ctx.Doer.IsAdmin && !ctxUser.IsOrganization() {
|
2021-07-15 20:19:39 +02:00
|
|
|
ctx.Error(http.StatusForbidden, "", "Only admin can generate repository for other user.")
|
2021-07-05 17:29:08 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:03:22 +01:00
|
|
|
if !ctx.Doer.IsAdmin {
|
2023-10-03 12:30:41 +02:00
|
|
|
canCreate, err := organization.OrgFromUser(ctxUser).CanCreateOrgRepo(ctx, ctx.Doer.ID)
|
2021-07-05 17:29:08 +02:00
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("CanCreateOrgRepo", err)
|
|
|
|
return
|
|
|
|
} else if !canCreate {
|
|
|
|
ctx.Error(http.StatusForbidden, "", "Given user is not allowed to create repository in organization.")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-28 23:17:51 +01:00
|
|
|
repo, err := repo_service.GenerateRepository(ctx, ctx.Doer, ctxUser, ctx.Repo.Repository, opts)
|
2021-07-05 17:29:08 +02:00
|
|
|
if err != nil {
|
2021-12-12 16:48:20 +01:00
|
|
|
if repo_model.IsErrRepoAlreadyExist(err) {
|
2021-07-05 17:29:08 +02:00
|
|
|
ctx.Error(http.StatusConflict, "", "The repository with the same name already exists.")
|
2021-11-24 10:49:20 +01:00
|
|
|
} else if db.IsErrNameReserved(err) ||
|
|
|
|
db.IsErrNamePatternNotAllowed(err) {
|
2021-07-05 17:29:08 +02:00
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", err)
|
|
|
|
} else {
|
|
|
|
ctx.Error(http.StatusInternalServerError, "CreateRepository", err)
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
log.Trace("Repository generated [%d]: %s/%s", repo.ID, ctxUser.Name, repo.Name)
|
|
|
|
|
2023-06-22 15:08:08 +02:00
|
|
|
ctx.JSON(http.StatusCreated, convert.ToRepo(ctx, repo, access_model.Permission{AccessMode: perm.AccessModeOwner}))
|
2021-07-05 17:29:08 +02:00
|
|
|
}
|
|
|
|
|
2020-01-09 17:40:01 +01:00
|
|
|
// CreateOrgRepoDeprecated create one repository of the organization
|
2021-01-26 16:36:53 +01:00
|
|
|
func CreateOrgRepoDeprecated(ctx *context.APIContext) {
|
2020-01-09 17:40:01 +01:00
|
|
|
// swagger:operation POST /org/{org}/repos organization createOrgRepoDeprecated
|
2017-11-13 08:02:25 +01:00
|
|
|
// ---
|
|
|
|
// summary: Create a repository in an organization
|
2020-01-09 17:40:01 +01:00
|
|
|
// deprecated: true
|
2017-11-13 08:02:25 +01:00
|
|
|
// consumes:
|
|
|
|
// - application/json
|
|
|
|
// produces:
|
|
|
|
// - application/json
|
|
|
|
// parameters:
|
|
|
|
// - name: org
|
|
|
|
// in: path
|
|
|
|
// description: name of organization
|
|
|
|
// type: string
|
|
|
|
// required: true
|
|
|
|
// - name: body
|
|
|
|
// in: body
|
|
|
|
// schema:
|
|
|
|
// "$ref": "#/definitions/CreateRepoOption"
|
|
|
|
// responses:
|
|
|
|
// "201":
|
|
|
|
// "$ref": "#/responses/Repository"
|
|
|
|
// "422":
|
|
|
|
// "$ref": "#/responses/validationError"
|
|
|
|
// "403":
|
|
|
|
// "$ref": "#/responses/forbidden"
|
2023-09-13 04:37:54 +02:00
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
2019-12-20 18:07:12 +01:00
|
|
|
|
2021-01-26 16:36:53 +01:00
|
|
|
CreateOrgRepo(ctx)
|
2020-01-09 17:40:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// CreateOrgRepo create one repository of the organization
|
2021-01-26 16:36:53 +01:00
|
|
|
func CreateOrgRepo(ctx *context.APIContext) {
|
2020-01-09 17:40:01 +01:00
|
|
|
// swagger:operation POST /orgs/{org}/repos organization createOrgRepo
|
|
|
|
// ---
|
|
|
|
// summary: Create a repository in an organization
|
|
|
|
// consumes:
|
|
|
|
// - application/json
|
|
|
|
// produces:
|
|
|
|
// - application/json
|
|
|
|
// parameters:
|
|
|
|
// - name: org
|
|
|
|
// in: path
|
|
|
|
// description: name of organization
|
|
|
|
// type: string
|
|
|
|
// required: true
|
|
|
|
// - name: body
|
|
|
|
// in: body
|
|
|
|
// schema:
|
|
|
|
// "$ref": "#/definitions/CreateRepoOption"
|
|
|
|
// responses:
|
|
|
|
// "201":
|
|
|
|
// "$ref": "#/responses/Repository"
|
2023-03-13 22:55:30 +01:00
|
|
|
// "400":
|
|
|
|
// "$ref": "#/responses/error"
|
2020-01-09 17:40:01 +01:00
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
|
|
|
// "403":
|
|
|
|
// "$ref": "#/responses/forbidden"
|
2021-01-26 16:36:53 +01:00
|
|
|
opt := web.GetForm(ctx).(*api.CreateRepoOption)
|
2023-02-08 07:44:42 +01:00
|
|
|
org, err := organization.GetOrgByName(ctx, ctx.Params(":org"))
|
2014-12-13 02:30:32 +01:00
|
|
|
if err != nil {
|
2022-03-29 08:29:02 +02:00
|
|
|
if organization.IsErrOrgNotExist(err) {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", err)
|
2014-12-13 02:30:32 +01:00
|
|
|
} else {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusInternalServerError, "GetOrgByName", err)
|
2014-12-13 02:30:32 +01:00
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-03-29 08:29:02 +02:00
|
|
|
if !organization.HasOrgOrUserVisible(ctx, org.AsUser(), ctx.Doer) {
|
2021-06-26 21:53:14 +02:00
|
|
|
ctx.NotFound("HasOrgOrUserVisible", nil)
|
2019-02-18 17:00:27 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:03:22 +01:00
|
|
|
if !ctx.Doer.IsAdmin {
|
2023-10-03 12:30:41 +02:00
|
|
|
canCreate, err := org.CanCreateOrgRepo(ctx, ctx.Doer.ID)
|
2018-07-05 01:51:02 +02:00
|
|
|
if err != nil {
|
2020-09-20 22:20:14 +02:00
|
|
|
ctx.Error(http.StatusInternalServerError, "CanCreateOrgRepo", err)
|
2018-07-05 01:51:02 +02:00
|
|
|
return
|
2019-11-20 12:27:49 +01:00
|
|
|
} else if !canCreate {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusForbidden, "", "Given user is not allowed to create repository in organization.")
|
2018-07-05 01:51:02 +02:00
|
|
|
return
|
|
|
|
}
|
2014-12-13 02:30:32 +01:00
|
|
|
}
|
2021-11-19 12:41:40 +01:00
|
|
|
CreateUserRepo(ctx, org.AsUser(), *opt)
|
2014-12-13 02:30:32 +01:00
|
|
|
}
|
|
|
|
|
2016-10-07 19:17:27 +02:00
|
|
|
// Get one repository
|
2016-03-13 23:49:16 +01:00
|
|
|
func Get(ctx *context.APIContext) {
|
2017-11-13 08:02:25 +01:00
|
|
|
// swagger:operation GET /repos/{owner}/{repo} repository repoGet
|
|
|
|
// ---
|
|
|
|
// summary: Get 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/Repository"
|
2023-09-13 04:37:54 +02:00
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
2019-12-20 18:07:12 +01:00
|
|
|
|
2022-01-25 07:33:40 +01:00
|
|
|
if err := ctx.Repo.Repository.LoadAttributes(ctx); err != nil {
|
|
|
|
ctx.Error(http.StatusInternalServerError, "Repository.LoadAttributes", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-06-22 15:08:08 +02:00
|
|
|
ctx.JSON(http.StatusOK, convert.ToRepo(ctx, ctx.Repo.Repository, ctx.Repo.Permission))
|
2015-10-22 23:46:07 +02:00
|
|
|
}
|
|
|
|
|
2016-10-03 12:35:42 +02:00
|
|
|
// GetByID returns a single Repository
|
|
|
|
func GetByID(ctx *context.APIContext) {
|
2017-11-13 08:02:25 +01:00
|
|
|
// swagger:operation GET /repositories/{id} repository repoGetByID
|
|
|
|
// ---
|
|
|
|
// summary: Get a repository by id
|
|
|
|
// produces:
|
|
|
|
// - application/json
|
|
|
|
// parameters:
|
|
|
|
// - name: id
|
|
|
|
// in: path
|
|
|
|
// description: id of the repo to get
|
|
|
|
// type: integer
|
2018-10-21 05:40:42 +02:00
|
|
|
// format: int64
|
2017-11-13 08:02:25 +01:00
|
|
|
// required: true
|
|
|
|
// responses:
|
|
|
|
// "200":
|
|
|
|
// "$ref": "#/responses/Repository"
|
2023-09-13 04:37:54 +02:00
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
2019-12-20 18:07:12 +01:00
|
|
|
|
2022-12-03 03:48:26 +01:00
|
|
|
repo, err := repo_model.GetRepositoryByID(ctx, ctx.ParamsInt64(":id"))
|
2016-10-03 12:35:42 +02:00
|
|
|
if err != nil {
|
2021-12-10 02:27:50 +01:00
|
|
|
if repo_model.IsErrRepoNotExist(err) {
|
2019-03-19 03:29:43 +01:00
|
|
|
ctx.NotFound()
|
2016-10-03 12:35:42 +02:00
|
|
|
} else {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusInternalServerError, "GetRepositoryByID", err)
|
2016-10-03 12:35:42 +02:00
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-06-22 15:08:08 +02:00
|
|
|
permission, err := access_model.GetUserRepoPermission(ctx, repo, ctx.Doer)
|
2016-12-06 00:48:51 +01:00
|
|
|
if err != nil {
|
2023-06-22 15:08:08 +02:00
|
|
|
ctx.Error(http.StatusInternalServerError, "GetUserRepoPermission", err)
|
2017-07-30 03:13:33 +02:00
|
|
|
return
|
2023-06-22 15:08:08 +02:00
|
|
|
} else if !permission.HasAccess() {
|
2019-03-19 03:29:43 +01:00
|
|
|
ctx.NotFound()
|
2016-12-06 00:48:51 +01:00
|
|
|
return
|
|
|
|
}
|
2023-06-22 15:08:08 +02:00
|
|
|
ctx.JSON(http.StatusOK, convert.ToRepo(ctx, repo, permission))
|
2016-10-03 12:35:42 +02:00
|
|
|
}
|
|
|
|
|
2019-05-30 17:09:05 +02:00
|
|
|
// Edit edit repository properties
|
2021-01-26 16:36:53 +01:00
|
|
|
func Edit(ctx *context.APIContext) {
|
2019-05-30 17:09:05 +02:00
|
|
|
// swagger:operation PATCH /repos/{owner}/{repo} repository repoEdit
|
|
|
|
// ---
|
|
|
|
// summary: Edit a repository's properties. Only fields that are set will be changed.
|
|
|
|
// produces:
|
|
|
|
// - application/json
|
|
|
|
// parameters:
|
|
|
|
// - name: owner
|
|
|
|
// in: path
|
|
|
|
// description: owner of the repo to edit
|
|
|
|
// type: string
|
|
|
|
// required: true
|
|
|
|
// - name: repo
|
|
|
|
// in: path
|
|
|
|
// description: name of the repo to edit
|
|
|
|
// type: string
|
|
|
|
// required: true
|
|
|
|
// - name: body
|
|
|
|
// in: body
|
|
|
|
// description: "Properties of a repo that you can edit"
|
|
|
|
// schema:
|
|
|
|
// "$ref": "#/definitions/EditRepoOption"
|
|
|
|
// responses:
|
|
|
|
// "200":
|
|
|
|
// "$ref": "#/responses/Repository"
|
|
|
|
// "403":
|
|
|
|
// "$ref": "#/responses/forbidden"
|
2023-09-13 04:37:54 +02:00
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
2019-05-30 17:09:05 +02:00
|
|
|
// "422":
|
|
|
|
// "$ref": "#/responses/validationError"
|
2019-12-20 18:07:12 +01:00
|
|
|
|
2021-01-26 16:36:53 +01:00
|
|
|
opts := *web.GetForm(ctx).(*api.EditRepoOption)
|
|
|
|
|
2019-05-30 17:09:05 +02:00
|
|
|
if err := updateBasicProperties(ctx, opts); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := updateRepoUnits(ctx, opts); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if opts.Archived != nil {
|
|
|
|
if err := updateRepoArchivedState(ctx, opts); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-01-25 13:51:32 +01:00
|
|
|
if opts.MirrorInterval != nil || opts.EnablePrune != nil {
|
2022-04-20 10:20:53 +02:00
|
|
|
if err := updateMirror(ctx, opts); err != nil {
|
2021-01-03 00:47:47 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-03 03:48:26 +01:00
|
|
|
repo, err := repo_model.GetRepositoryByID(ctx, ctx.Repo.Repository.ID)
|
2021-07-13 21:31:59 +02:00
|
|
|
if err != nil {
|
|
|
|
ctx.InternalServerError(err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-06-22 15:08:08 +02:00
|
|
|
ctx.JSON(http.StatusOK, convert.ToRepo(ctx, repo, ctx.Repo.Permission))
|
2019-05-30 17:09:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// updateBasicProperties updates the basic properties of a repo: Name, Description, Website and Visibility
|
|
|
|
func updateBasicProperties(ctx *context.APIContext, opts api.EditRepoOption) error {
|
|
|
|
owner := ctx.Repo.Owner
|
|
|
|
repo := ctx.Repo.Repository
|
|
|
|
newRepoName := repo.Name
|
|
|
|
if opts.Name != nil {
|
|
|
|
newRepoName = *opts.Name
|
|
|
|
}
|
|
|
|
// Check if repository name has been changed and not just a case change
|
|
|
|
if repo.LowerName != strings.ToLower(newRepoName) {
|
2023-02-28 23:17:51 +01:00
|
|
|
if err := repo_service.ChangeRepositoryName(ctx, ctx.Doer, repo, newRepoName); err != nil {
|
2019-05-30 17:09:05 +02:00
|
|
|
switch {
|
2021-12-12 16:48:20 +01:00
|
|
|
case repo_model.IsErrRepoAlreadyExist(err):
|
2019-05-30 17:09:05 +02:00
|
|
|
ctx.Error(http.StatusUnprocessableEntity, fmt.Sprintf("repo name is already taken [name: %s]", newRepoName), err)
|
2021-11-24 10:49:20 +01:00
|
|
|
case db.IsErrNameReserved(err):
|
2019-05-30 17:09:05 +02:00
|
|
|
ctx.Error(http.StatusUnprocessableEntity, fmt.Sprintf("repo name is reserved [name: %s]", newRepoName), err)
|
2021-11-24 10:49:20 +01:00
|
|
|
case db.IsErrNamePatternNotAllowed(err):
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, fmt.Sprintf("repo name's pattern is not allowed [name: %s, pattern: %s]", newRepoName, err.(db.ErrNamePatternNotAllowed).Pattern), err)
|
2019-05-30 17:09:05 +02:00
|
|
|
default:
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "ChangeRepositoryName", err)
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Trace("Repository name changed: %s/%s -> %s", ctx.Repo.Owner.Name, repo.Name, newRepoName)
|
|
|
|
}
|
|
|
|
// Update the name in the repo object for the response
|
|
|
|
repo.Name = newRepoName
|
|
|
|
repo.LowerName = strings.ToLower(newRepoName)
|
|
|
|
|
|
|
|
if opts.Description != nil {
|
|
|
|
repo.Description = *opts.Description
|
|
|
|
}
|
|
|
|
|
|
|
|
if opts.Website != nil {
|
|
|
|
repo.Website = *opts.Website
|
|
|
|
}
|
|
|
|
|
|
|
|
visibilityChanged := false
|
|
|
|
if opts.Private != nil {
|
|
|
|
// Visibility of forked repository is forced sync with base repository.
|
|
|
|
if repo.IsFork {
|
2022-12-03 03:48:26 +01:00
|
|
|
if err := repo.GetBaseRepo(ctx); err != nil {
|
2021-03-11 19:09:52 +01:00
|
|
|
ctx.Error(http.StatusInternalServerError, "Unable to load base repository", err)
|
|
|
|
return err
|
|
|
|
}
|
2019-05-30 17:09:05 +02:00
|
|
|
*opts.Private = repo.BaseRepo.IsPrivate
|
|
|
|
}
|
|
|
|
|
|
|
|
visibilityChanged = repo.IsPrivate != *opts.Private
|
|
|
|
// when ForcePrivate enabled, you could change public repo to private, but only admin users can change private to public
|
2022-03-22 08:03:22 +01:00
|
|
|
if visibilityChanged && setting.Repository.ForcePrivate && !*opts.Private && !ctx.Doer.IsAdmin {
|
2019-05-30 17:09:05 +02:00
|
|
|
err := fmt.Errorf("cannot change private repository to public")
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "Force Private enabled", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
repo.IsPrivate = *opts.Private
|
|
|
|
}
|
|
|
|
|
2019-11-11 16:15:29 +01:00
|
|
|
if opts.Template != nil {
|
|
|
|
repo.IsTemplate = *opts.Template
|
|
|
|
}
|
|
|
|
|
2021-05-08 14:11:36 +02:00
|
|
|
if ctx.Repo.GitRepo == nil && !repo.IsEmpty {
|
2021-02-11 20:53:41 +01:00
|
|
|
var err error
|
2024-03-08 08:30:10 +01:00
|
|
|
ctx.Repo.GitRepo, err = gitrepo.OpenRepository(ctx, repo)
|
2021-02-11 20:53:41 +01:00
|
|
|
if err != nil {
|
|
|
|
ctx.Error(http.StatusInternalServerError, "Unable to OpenRepository", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer ctx.Repo.GitRepo.Close()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Default branch only updated if changed and exist or the repository is empty
|
2021-05-08 14:11:36 +02:00
|
|
|
if opts.DefaultBranch != nil && repo.DefaultBranch != *opts.DefaultBranch && (repo.IsEmpty || ctx.Repo.GitRepo.IsBranchExist(*opts.DefaultBranch)) {
|
|
|
|
if !repo.IsEmpty {
|
2024-03-08 08:30:10 +01:00
|
|
|
if err := gitrepo.SetDefaultBranch(ctx, ctx.Repo.Repository, *opts.DefaultBranch); err != nil {
|
2021-05-08 14:11:36 +02:00
|
|
|
if !git.IsErrUnsupportedVersion(err) {
|
|
|
|
ctx.Error(http.StatusInternalServerError, "SetDefaultBranch", err)
|
|
|
|
return err
|
|
|
|
}
|
2019-11-17 07:30:01 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
repo.DefaultBranch = *opts.DefaultBranch
|
|
|
|
}
|
|
|
|
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 12:18:53 +01:00
|
|
|
// Wiki branch is updated if changed
|
|
|
|
if opts.WikiBranch != nil && repo.WikiBranch != *opts.WikiBranch {
|
|
|
|
if err := wiki_service.NormalizeWikiBranch(ctx, repo, *opts.WikiBranch); err != nil {
|
|
|
|
ctx.Error(http.StatusInternalServerError, "NormalizeWikiBranch", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
// While NormalizeWikiBranch updates the db, we need to update *this*
|
|
|
|
// instance of `repo`, so that the `UpdateRepository` below will not
|
|
|
|
// reset the branch back.
|
|
|
|
repo.WikiBranch = *opts.WikiBranch
|
|
|
|
}
|
|
|
|
|
2023-02-28 23:17:51 +01:00
|
|
|
if err := repo_service.UpdateRepository(ctx, repo, visibilityChanged); err != nil {
|
2019-05-30 17:09:05 +02:00
|
|
|
ctx.Error(http.StatusInternalServerError, "UpdateRepository", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Trace("Repository basic settings updated: %s/%s", owner.Name, repo.Name)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// updateRepoUnits updates repo units: Issue settings, Wiki settings, PR settings
|
|
|
|
func updateRepoUnits(ctx *context.APIContext, opts api.EditRepoOption) error {
|
|
|
|
owner := ctx.Repo.Owner
|
|
|
|
repo := ctx.Repo.Repository
|
|
|
|
|
2021-12-10 02:27:50 +01:00
|
|
|
var units []repo_model.RepoUnit
|
2021-11-09 20:57:58 +01:00
|
|
|
var deleteUnitTypes []unit_model.Type
|
2019-05-30 17:09:05 +02:00
|
|
|
|
2022-12-10 03:46:31 +01:00
|
|
|
currHasIssues := repo.UnitEnabled(ctx, unit_model.TypeIssues)
|
2022-09-28 00:23:58 +02:00
|
|
|
newHasIssues := currHasIssues
|
2020-01-17 08:34:37 +01:00
|
|
|
if opts.HasIssues != nil {
|
2022-09-28 00:23:58 +02:00
|
|
|
newHasIssues = *opts.HasIssues
|
|
|
|
}
|
|
|
|
if currHasIssues || newHasIssues {
|
|
|
|
if newHasIssues && opts.ExternalTracker != nil && !unit_model.TypeExternalTracker.UnitGlobalDisabled() {
|
2019-10-02 11:30:41 +02:00
|
|
|
// Check that values are valid
|
|
|
|
if !validation.IsValidExternalURL(opts.ExternalTracker.ExternalTrackerURL) {
|
|
|
|
err := fmt.Errorf("External tracker URL not valid")
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "Invalid external tracker URL", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if len(opts.ExternalTracker.ExternalTrackerFormat) != 0 && !validation.IsValidExternalTrackerURLFormat(opts.ExternalTracker.ExternalTrackerFormat) {
|
|
|
|
err := fmt.Errorf("External tracker URL format not valid")
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "Invalid external tracker URL format", err)
|
|
|
|
return err
|
2019-05-30 17:09:05 +02:00
|
|
|
}
|
2019-10-02 11:30:41 +02:00
|
|
|
|
2021-12-10 02:27:50 +01:00
|
|
|
units = append(units, repo_model.RepoUnit{
|
2019-10-02 11:30:41 +02:00
|
|
|
RepoID: repo.ID,
|
2021-11-09 20:57:58 +01:00
|
|
|
Type: unit_model.TypeExternalTracker,
|
2021-12-10 02:27:50 +01:00
|
|
|
Config: &repo_model.ExternalTrackerConfig{
|
2022-10-07 14:49:30 +02:00
|
|
|
ExternalTrackerURL: opts.ExternalTracker.ExternalTrackerURL,
|
|
|
|
ExternalTrackerFormat: opts.ExternalTracker.ExternalTrackerFormat,
|
|
|
|
ExternalTrackerStyle: opts.ExternalTracker.ExternalTrackerStyle,
|
|
|
|
ExternalTrackerRegexpPattern: opts.ExternalTracker.ExternalTrackerRegexpPattern,
|
2019-10-02 11:30:41 +02:00
|
|
|
},
|
|
|
|
})
|
2021-11-09 20:57:58 +01:00
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeIssues)
|
2022-09-28 00:23:58 +02:00
|
|
|
} else if newHasIssues && opts.ExternalTracker == nil && !unit_model.TypeIssues.UnitGlobalDisabled() {
|
2019-10-02 11:30:41 +02:00
|
|
|
// Default to built-in tracker
|
2021-12-10 02:27:50 +01:00
|
|
|
var config *repo_model.IssuesConfig
|
2019-10-02 11:30:41 +02:00
|
|
|
|
|
|
|
if opts.InternalTracker != nil {
|
2021-12-10 02:27:50 +01:00
|
|
|
config = &repo_model.IssuesConfig{
|
2019-10-02 11:30:41 +02:00
|
|
|
EnableTimetracker: opts.InternalTracker.EnableTimeTracker,
|
|
|
|
AllowOnlyContributorsToTrackTime: opts.InternalTracker.AllowOnlyContributorsToTrackTime,
|
|
|
|
EnableDependencies: opts.InternalTracker.EnableIssueDependencies,
|
|
|
|
}
|
2022-12-10 03:46:31 +01:00
|
|
|
} else if unit, err := repo.GetUnit(ctx, unit_model.TypeIssues); err != nil {
|
2019-10-02 11:30:41 +02:00
|
|
|
// Unit type doesn't exist so we make a new config file with default values
|
2021-12-10 02:27:50 +01:00
|
|
|
config = &repo_model.IssuesConfig{
|
2019-10-02 11:30:41 +02:00
|
|
|
EnableTimetracker: true,
|
|
|
|
AllowOnlyContributorsToTrackTime: true,
|
|
|
|
EnableDependencies: true,
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
config = unit.IssuesConfig()
|
|
|
|
}
|
|
|
|
|
2021-12-10 02:27:50 +01:00
|
|
|
units = append(units, repo_model.RepoUnit{
|
2019-10-02 11:30:41 +02:00
|
|
|
RepoID: repo.ID,
|
2021-11-09 20:57:58 +01:00
|
|
|
Type: unit_model.TypeIssues,
|
2019-10-02 11:30:41 +02:00
|
|
|
Config: config,
|
|
|
|
})
|
2021-11-09 20:57:58 +01:00
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeExternalTracker)
|
2022-09-28 00:23:58 +02:00
|
|
|
} else if !newHasIssues {
|
2021-11-09 20:57:58 +01:00
|
|
|
if !unit_model.TypeExternalTracker.UnitGlobalDisabled() {
|
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeExternalTracker)
|
2020-01-17 08:34:37 +01:00
|
|
|
}
|
2021-11-09 20:57:58 +01:00
|
|
|
if !unit_model.TypeIssues.UnitGlobalDisabled() {
|
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeIssues)
|
2020-01-17 08:34:37 +01:00
|
|
|
}
|
2019-05-30 17:09:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-10 03:46:31 +01:00
|
|
|
currHasWiki := repo.UnitEnabled(ctx, unit_model.TypeWiki)
|
2022-09-28 00:23:58 +02:00
|
|
|
newHasWiki := currHasWiki
|
2020-01-17 08:34:37 +01:00
|
|
|
if opts.HasWiki != nil {
|
2022-09-28 00:23:58 +02:00
|
|
|
newHasWiki = *opts.HasWiki
|
|
|
|
}
|
|
|
|
if currHasWiki || newHasWiki {
|
2024-04-16 22:51:36 +02:00
|
|
|
wikiPermissions := repo.MustGetUnit(ctx, unit_model.TypeWiki).DefaultPermissions
|
|
|
|
if opts.GloballyEditableWiki != nil {
|
|
|
|
if *opts.GloballyEditableWiki {
|
|
|
|
wikiPermissions = repo_model.UnitAccessModeWrite
|
|
|
|
} else {
|
|
|
|
wikiPermissions = repo_model.UnitAccessModeRead
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-28 00:23:58 +02:00
|
|
|
if newHasWiki && opts.ExternalWiki != nil && !unit_model.TypeExternalWiki.UnitGlobalDisabled() {
|
2019-10-02 11:30:41 +02:00
|
|
|
// Check that values are valid
|
|
|
|
if !validation.IsValidExternalURL(opts.ExternalWiki.ExternalWikiURL) {
|
|
|
|
err := fmt.Errorf("External wiki URL not valid")
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "", "Invalid external wiki URL")
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-12-10 02:27:50 +01:00
|
|
|
units = append(units, repo_model.RepoUnit{
|
2019-10-02 11:30:41 +02:00
|
|
|
RepoID: repo.ID,
|
2021-11-09 20:57:58 +01:00
|
|
|
Type: unit_model.TypeExternalWiki,
|
2021-12-10 02:27:50 +01:00
|
|
|
Config: &repo_model.ExternalWikiConfig{
|
2019-10-02 11:30:41 +02:00
|
|
|
ExternalWikiURL: opts.ExternalWiki.ExternalWikiURL,
|
|
|
|
},
|
|
|
|
})
|
2021-11-09 20:57:58 +01:00
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeWiki)
|
2022-09-28 00:23:58 +02:00
|
|
|
} else if newHasWiki && opts.ExternalWiki == nil && !unit_model.TypeWiki.UnitGlobalDisabled() {
|
2021-12-10 02:27:50 +01:00
|
|
|
config := &repo_model.UnitConfig{}
|
|
|
|
units = append(units, repo_model.RepoUnit{
|
2024-04-16 22:51:36 +02:00
|
|
|
RepoID: repo.ID,
|
|
|
|
Type: unit_model.TypeWiki,
|
|
|
|
Config: config,
|
|
|
|
DefaultPermissions: wikiPermissions,
|
2019-10-02 11:30:41 +02:00
|
|
|
})
|
2021-11-09 20:57:58 +01:00
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeExternalWiki)
|
2022-09-28 00:23:58 +02:00
|
|
|
} else if !newHasWiki {
|
2021-11-09 20:57:58 +01:00
|
|
|
if !unit_model.TypeExternalWiki.UnitGlobalDisabled() {
|
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeExternalWiki)
|
2020-01-17 08:34:37 +01:00
|
|
|
}
|
2021-11-09 20:57:58 +01:00
|
|
|
if !unit_model.TypeWiki.UnitGlobalDisabled() {
|
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeWiki)
|
2020-01-17 08:34:37 +01:00
|
|
|
}
|
2024-04-16 22:51:36 +02:00
|
|
|
} else if *opts.GloballyEditableWiki {
|
|
|
|
config := &repo_model.UnitConfig{}
|
|
|
|
units = append(units, repo_model.RepoUnit{
|
|
|
|
RepoID: repo.ID,
|
|
|
|
Type: unit_model.TypeWiki,
|
|
|
|
Config: config,
|
|
|
|
DefaultPermissions: wikiPermissions,
|
|
|
|
})
|
2019-10-02 11:30:41 +02:00
|
|
|
}
|
2019-05-30 17:09:05 +02:00
|
|
|
}
|
|
|
|
|
2022-12-10 03:46:31 +01:00
|
|
|
currHasPullRequests := repo.UnitEnabled(ctx, unit_model.TypePullRequests)
|
2022-09-28 00:23:58 +02:00
|
|
|
newHasPullRequests := currHasPullRequests
|
2020-01-17 08:34:37 +01:00
|
|
|
if opts.HasPullRequests != nil {
|
2022-09-28 00:23:58 +02:00
|
|
|
newHasPullRequests = *opts.HasPullRequests
|
|
|
|
}
|
|
|
|
if currHasPullRequests || newHasPullRequests {
|
|
|
|
if newHasPullRequests && !unit_model.TypePullRequests.UnitGlobalDisabled() {
|
2020-01-17 08:34:37 +01:00
|
|
|
// We do allow setting individual PR settings through the API, so
|
|
|
|
// we get the config settings and then set them
|
|
|
|
// if those settings were provided in the opts.
|
2022-12-10 03:46:31 +01:00
|
|
|
unit, err := repo.GetUnit(ctx, unit_model.TypePullRequests)
|
2021-12-10 02:27:50 +01:00
|
|
|
var config *repo_model.PullRequestsConfig
|
2020-01-17 08:34:37 +01:00
|
|
|
if err != nil {
|
|
|
|
// Unit type doesn't exist so we make a new config file with default values
|
2021-12-10 02:27:50 +01:00
|
|
|
config = &repo_model.PullRequestsConfig{
|
2021-07-13 01:26:25 +02:00
|
|
|
IgnoreWhitespaceConflicts: false,
|
|
|
|
AllowMerge: true,
|
|
|
|
AllowRebase: true,
|
|
|
|
AllowRebaseMerge: true,
|
|
|
|
AllowSquash: true,
|
2024-02-12 23:37:23 +01:00
|
|
|
AllowFastForwardOnly: true,
|
2021-07-13 01:26:25 +02:00
|
|
|
AllowManualMerge: true,
|
|
|
|
AutodetectManualMerge: false,
|
2022-03-04 09:30:49 +01:00
|
|
|
AllowRebaseUpdate: true,
|
2021-07-13 01:26:25 +02:00
|
|
|
DefaultDeleteBranchAfterMerge: false,
|
2021-12-10 02:27:50 +01:00
|
|
|
DefaultMergeStyle: repo_model.MergeStyleMerge,
|
2023-02-13 07:09:52 +01:00
|
|
|
DefaultAllowMaintainerEdit: false,
|
2020-01-17 08:34:37 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
config = unit.PullRequestsConfig()
|
2019-05-30 17:09:05 +02:00
|
|
|
}
|
|
|
|
|
2020-01-17 08:34:37 +01:00
|
|
|
if opts.IgnoreWhitespaceConflicts != nil {
|
|
|
|
config.IgnoreWhitespaceConflicts = *opts.IgnoreWhitespaceConflicts
|
|
|
|
}
|
|
|
|
if opts.AllowMerge != nil {
|
|
|
|
config.AllowMerge = *opts.AllowMerge
|
|
|
|
}
|
|
|
|
if opts.AllowRebase != nil {
|
|
|
|
config.AllowRebase = *opts.AllowRebase
|
|
|
|
}
|
|
|
|
if opts.AllowRebaseMerge != nil {
|
|
|
|
config.AllowRebaseMerge = *opts.AllowRebaseMerge
|
|
|
|
}
|
|
|
|
if opts.AllowSquash != nil {
|
|
|
|
config.AllowSquash = *opts.AllowSquash
|
|
|
|
}
|
2024-02-12 23:37:23 +01:00
|
|
|
if opts.AllowFastForwardOnly != nil {
|
|
|
|
config.AllowFastForwardOnly = *opts.AllowFastForwardOnly
|
|
|
|
}
|
2021-03-04 04:41:23 +01:00
|
|
|
if opts.AllowManualMerge != nil {
|
|
|
|
config.AllowManualMerge = *opts.AllowManualMerge
|
|
|
|
}
|
|
|
|
if opts.AutodetectManualMerge != nil {
|
|
|
|
config.AutodetectManualMerge = *opts.AutodetectManualMerge
|
|
|
|
}
|
2022-03-04 09:30:49 +01:00
|
|
|
if opts.AllowRebaseUpdate != nil {
|
|
|
|
config.AllowRebaseUpdate = *opts.AllowRebaseUpdate
|
|
|
|
}
|
2021-07-13 01:26:25 +02:00
|
|
|
if opts.DefaultDeleteBranchAfterMerge != nil {
|
|
|
|
config.DefaultDeleteBranchAfterMerge = *opts.DefaultDeleteBranchAfterMerge
|
|
|
|
}
|
2021-03-27 15:55:40 +01:00
|
|
|
if opts.DefaultMergeStyle != nil {
|
2021-12-10 02:27:50 +01:00
|
|
|
config.DefaultMergeStyle = repo_model.MergeStyle(*opts.DefaultMergeStyle)
|
2021-03-27 15:55:40 +01:00
|
|
|
}
|
2023-02-13 07:09:52 +01:00
|
|
|
if opts.DefaultAllowMaintainerEdit != nil {
|
|
|
|
config.DefaultAllowMaintainerEdit = *opts.DefaultAllowMaintainerEdit
|
|
|
|
}
|
2019-08-10 11:32:46 +02:00
|
|
|
|
2021-12-10 02:27:50 +01:00
|
|
|
units = append(units, repo_model.RepoUnit{
|
2020-01-17 08:34:37 +01:00
|
|
|
RepoID: repo.ID,
|
2021-11-09 20:57:58 +01:00
|
|
|
Type: unit_model.TypePullRequests,
|
2020-01-17 08:34:37 +01:00
|
|
|
Config: config,
|
|
|
|
})
|
2022-09-28 00:23:58 +02:00
|
|
|
} else if !newHasPullRequests && !unit_model.TypePullRequests.UnitGlobalDisabled() {
|
2021-11-09 20:57:58 +01:00
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypePullRequests)
|
2020-01-17 08:34:37 +01:00
|
|
|
}
|
2019-05-30 17:09:05 +02:00
|
|
|
}
|
|
|
|
|
2021-11-09 20:57:58 +01:00
|
|
|
if opts.HasProjects != nil && !unit_model.TypeProjects.UnitGlobalDisabled() {
|
2020-08-17 05:07:38 +02:00
|
|
|
if *opts.HasProjects {
|
2021-12-10 02:27:50 +01:00
|
|
|
units = append(units, repo_model.RepoUnit{
|
2020-08-17 05:07:38 +02:00
|
|
|
RepoID: repo.ID,
|
2021-11-09 20:57:58 +01:00
|
|
|
Type: unit_model.TypeProjects,
|
2020-08-17 05:07:38 +02:00
|
|
|
})
|
|
|
|
} else {
|
2021-11-09 20:57:58 +01:00
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeProjects)
|
2020-08-17 05:07:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-16 18:30:42 +01:00
|
|
|
if opts.HasReleases != nil && !unit_model.TypeReleases.UnitGlobalDisabled() {
|
|
|
|
if *opts.HasReleases {
|
|
|
|
units = append(units, repo_model.RepoUnit{
|
|
|
|
RepoID: repo.ID,
|
|
|
|
Type: unit_model.TypeReleases,
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeReleases)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if opts.HasPackages != nil && !unit_model.TypePackages.UnitGlobalDisabled() {
|
|
|
|
if *opts.HasPackages {
|
|
|
|
units = append(units, repo_model.RepoUnit{
|
|
|
|
RepoID: repo.ID,
|
|
|
|
Type: unit_model.TypePackages,
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypePackages)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if opts.HasActions != nil && !unit_model.TypeActions.UnitGlobalDisabled() {
|
|
|
|
if *opts.HasActions {
|
|
|
|
units = append(units, repo_model.RepoUnit{
|
|
|
|
RepoID: repo.ID,
|
|
|
|
Type: unit_model.TypeActions,
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
deleteUnitTypes = append(deleteUnitTypes, unit_model.TypeActions)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-05-06 11:39:06 +02:00
|
|
|
if len(units)+len(deleteUnitTypes) > 0 {
|
2024-01-12 22:50:38 +01:00
|
|
|
if err := repo_service.UpdateRepositoryUnits(ctx, repo, units, deleteUnitTypes); err != nil {
|
2023-05-06 11:39:06 +02:00
|
|
|
ctx.Error(http.StatusInternalServerError, "UpdateRepositoryUnits", err)
|
|
|
|
return err
|
|
|
|
}
|
2019-05-30 17:09:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
log.Trace("Repository advanced settings updated: %s/%s", owner.Name, repo.Name)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// updateRepoArchivedState updates repo's archive state
|
|
|
|
func updateRepoArchivedState(ctx *context.APIContext, opts api.EditRepoOption) error {
|
|
|
|
repo := ctx.Repo.Repository
|
|
|
|
// archive / un-archive
|
|
|
|
if opts.Archived != nil {
|
|
|
|
if repo.IsMirror {
|
|
|
|
err := fmt.Errorf("repo is a mirror, cannot archive/un-archive")
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, err.Error(), err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if *opts.Archived {
|
2023-09-16 16:39:12 +02:00
|
|
|
if err := repo_model.SetArchiveRepoState(ctx, repo, *opts.Archived); err != nil {
|
2019-05-30 17:09:05 +02:00
|
|
|
log.Error("Tried to archive a repo: %s", err)
|
|
|
|
ctx.Error(http.StatusInternalServerError, "ArchiveRepoState", err)
|
|
|
|
return err
|
|
|
|
}
|
2024-04-01 15:48:14 +02:00
|
|
|
if err := actions_model.CleanRepoScheduleTasks(ctx, repo); err != nil {
|
|
|
|
log.Error("CleanRepoScheduleTasks for archived repo %s/%s: %v", ctx.Repo.Owner.Name, repo.Name, err)
|
|
|
|
}
|
2019-05-30 17:09:05 +02:00
|
|
|
log.Trace("Repository was archived: %s/%s", ctx.Repo.Owner.Name, repo.Name)
|
|
|
|
} else {
|
2023-09-16 16:39:12 +02:00
|
|
|
if err := repo_model.SetArchiveRepoState(ctx, repo, *opts.Archived); err != nil {
|
2019-05-30 17:09:05 +02:00
|
|
|
log.Error("Tried to un-archive a repo: %s", err)
|
|
|
|
ctx.Error(http.StatusInternalServerError, "ArchiveRepoState", err)
|
|
|
|
return err
|
|
|
|
}
|
2024-04-01 15:48:14 +02:00
|
|
|
if ctx.Repo.Repository.UnitEnabled(ctx, unit_model.TypeActions) {
|
|
|
|
if err := actions_service.DetectAndHandleSchedules(ctx, repo); err != nil {
|
|
|
|
log.Error("DetectAndHandleSchedules for un-archived repo %s/%s: %v", ctx.Repo.Owner.Name, repo.Name, err)
|
|
|
|
}
|
|
|
|
}
|
2019-05-30 17:09:05 +02:00
|
|
|
log.Trace("Repository was un-archived: %s/%s", ctx.Repo.Owner.Name, repo.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-04-20 10:20:53 +02:00
|
|
|
// updateMirror updates a repo's mirror Interval and EnablePrune
|
|
|
|
func updateMirror(ctx *context.APIContext, opts api.EditRepoOption) error {
|
2021-01-03 00:47:47 +01:00
|
|
|
repo := ctx.Repo.Repository
|
|
|
|
|
2022-04-20 10:20:53 +02:00
|
|
|
// only update mirror if interval or enable prune are provided
|
|
|
|
if opts.MirrorInterval == nil && opts.EnablePrune == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// these values only make sense if the repo is a mirror
|
|
|
|
if !repo.IsMirror {
|
|
|
|
err := fmt.Errorf("repo is not a mirror, can not change mirror interval")
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, err.Error(), err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the mirror from the repo
|
2022-05-20 16:08:52 +02:00
|
|
|
mirror, err := repo_model.GetMirrorByRepoID(ctx, repo.ID)
|
2022-04-20 10:20:53 +02:00
|
|
|
if err != nil {
|
|
|
|
log.Error("Failed to get mirror: %s", err)
|
|
|
|
ctx.Error(http.StatusInternalServerError, "MirrorInterval", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// update MirrorInterval
|
2021-01-03 00:47:47 +01:00
|
|
|
if opts.MirrorInterval != nil {
|
2022-04-20 10:20:53 +02:00
|
|
|
|
|
|
|
// MirrorInterval should be a duration
|
|
|
|
interval, err := time.ParseDuration(*opts.MirrorInterval)
|
2021-12-10 02:27:50 +01:00
|
|
|
if err != nil {
|
2022-04-20 10:20:53 +02:00
|
|
|
log.Error("Wrong format for MirrorInternal Sent: %s", err)
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "MirrorInterval", err)
|
2021-01-03 00:47:47 +01:00
|
|
|
return err
|
|
|
|
}
|
2022-04-20 10:20:53 +02:00
|
|
|
|
|
|
|
// Ensure the provided duration is not too short
|
|
|
|
if interval != 0 && interval < setting.Mirror.MinInterval {
|
|
|
|
err := fmt.Errorf("invalid mirror interval: %s is below minimum interval: %s", interval, setting.Mirror.MinInterval)
|
2021-01-03 00:47:47 +01:00
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "MirrorInterval", err)
|
|
|
|
return err
|
|
|
|
}
|
2022-04-20 10:20:53 +02:00
|
|
|
|
|
|
|
mirror.Interval = interval
|
|
|
|
mirror.Repo = repo
|
|
|
|
mirror.ScheduleNextUpdate()
|
|
|
|
log.Trace("Repository %s Mirror[%d] Set Interval: %s NextUpdateUnix: %s", repo.FullName(), mirror.ID, interval, mirror.NextUpdateUnix)
|
2021-01-03 00:47:47 +01:00
|
|
|
}
|
2022-04-20 10:20:53 +02:00
|
|
|
|
|
|
|
// update EnablePrune
|
|
|
|
if opts.EnablePrune != nil {
|
|
|
|
mirror.EnablePrune = *opts.EnablePrune
|
|
|
|
log.Trace("Repository %s Mirror[%d] Set EnablePrune: %t", repo.FullName(), mirror.ID, mirror.EnablePrune)
|
|
|
|
}
|
|
|
|
|
|
|
|
// finally update the mirror in the DB
|
2022-05-20 16:08:52 +02:00
|
|
|
if err := repo_model.UpdateMirror(ctx, mirror); err != nil {
|
2022-04-20 10:20:53 +02:00
|
|
|
log.Error("Failed to Set Mirror Interval: %s", err)
|
|
|
|
ctx.Error(http.StatusUnprocessableEntity, "MirrorInterval", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-01-03 00:47:47 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-10-07 19:17:27 +02:00
|
|
|
// Delete one repository
|
2016-03-13 23:49:16 +01:00
|
|
|
func Delete(ctx *context.APIContext) {
|
2017-11-13 08:02:25 +01:00
|
|
|
// swagger:operation DELETE /repos/{owner}/{repo} repository repoDelete
|
|
|
|
// ---
|
|
|
|
// summary: Delete a repository
|
|
|
|
// produces:
|
|
|
|
// - application/json
|
|
|
|
// parameters:
|
|
|
|
// - name: owner
|
|
|
|
// in: path
|
|
|
|
// description: owner of the repo to delete
|
|
|
|
// type: string
|
|
|
|
// required: true
|
|
|
|
// - name: repo
|
|
|
|
// in: path
|
|
|
|
// description: name of the repo to delete
|
|
|
|
// type: string
|
|
|
|
// required: true
|
|
|
|
// responses:
|
|
|
|
// "204":
|
|
|
|
// "$ref": "#/responses/empty"
|
|
|
|
// "403":
|
|
|
|
// "$ref": "#/responses/forbidden"
|
2023-09-13 04:37:54 +02:00
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
2019-12-20 18:07:12 +01:00
|
|
|
|
2016-11-14 23:33:58 +01:00
|
|
|
owner := ctx.Repo.Owner
|
|
|
|
repo := ctx.Repo.Repository
|
2015-10-04 17:09:16 +02:00
|
|
|
|
2023-09-25 15:17:37 +02:00
|
|
|
canDelete, err := repo_module.CanUserDelete(ctx, repo, ctx.Doer)
|
2019-10-26 08:54:11 +02:00
|
|
|
if err != nil {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusInternalServerError, "CanUserDelete", err)
|
2019-10-26 08:54:11 +02:00
|
|
|
return
|
|
|
|
} else if !canDelete {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusForbidden, "", "Given user is not owner of organization.")
|
2019-10-26 08:54:11 +02:00
|
|
|
return
|
2015-10-04 17:09:16 +02:00
|
|
|
}
|
|
|
|
|
2021-05-14 22:19:38 +02:00
|
|
|
if ctx.Repo.GitRepo != nil {
|
|
|
|
ctx.Repo.GitRepo.Close()
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:03:22 +01:00
|
|
|
if err := repo_service.DeleteRepository(ctx, ctx.Doer, repo, true); err != nil {
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Error(http.StatusInternalServerError, "DeleteRepository", err)
|
2015-10-04 17:09:16 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-10-22 23:46:07 +02:00
|
|
|
log.Trace("Repository deleted: %s/%s", owner.Name, repo.Name)
|
2019-12-20 18:07:12 +01:00
|
|
|
ctx.Status(http.StatusNoContent)
|
2015-10-04 17:09:16 +02:00
|
|
|
}
|
2020-09-11 16:48:39 +02:00
|
|
|
|
|
|
|
// GetIssueTemplates returns the issue templates for a repository
|
|
|
|
func GetIssueTemplates(ctx *context.APIContext) {
|
|
|
|
// swagger:operation GET /repos/{owner}/{repo}/issue_templates repository repoGetIssueTemplates
|
|
|
|
// ---
|
|
|
|
// summary: Get available issue templates for 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/IssueTemplates"
|
2023-09-13 04:37:54 +02:00
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
Fix `/api/v1/{owner}/{repo}/issue_templates`
When issue templates were moved into services in
def4956122ea2364f247712b13856383ee496add, the code was also refactored
and simplified. Unfortunately, that simplification broke the
`/api/v1/{owner}/{repo}/issue_templates` route, because it was
previously using a helper function that ignored invalid templates, and
after the refactor, the function it called *always* returned non-nil as
the second return value. This, in turn, results in the aforementioned
end point always returning an internal server error.
This change restores the previous behaviour of ignoring invalid files
returned by `issue.GetTemplatesFromDefaultBranch`, and adds a few test
cases to exercise the endpoint.
Other users of `GetTemplatesFromDefaultBranch` already ignore the second
return value, or handle it correctly, so no changes are necessary there.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
2024-02-05 12:42:52 +01:00
|
|
|
ret, _ := issue.GetTemplatesFromDefaultBranch(ctx.Repo.Repository, ctx.Repo.GitRepo)
|
2023-05-09 01:30:14 +02:00
|
|
|
ctx.JSON(http.StatusOK, ret)
|
2020-09-11 16:48:39 +02:00
|
|
|
}
|
2023-03-28 20:22:07 +02:00
|
|
|
|
|
|
|
// GetIssueConfig returns the issue config for a repo
|
|
|
|
func GetIssueConfig(ctx *context.APIContext) {
|
|
|
|
// swagger:operation GET /repos/{owner}/{repo}/issue_config repository repoGetIssueConfig
|
|
|
|
// ---
|
|
|
|
// summary: Returns the issue config for a repo
|
|
|
|
// 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/RepoIssueConfig"
|
2023-09-13 04:37:54 +02:00
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
2023-05-09 01:30:14 +02:00
|
|
|
issueConfig, _ := issue.GetTemplateConfigFromDefaultBranch(ctx.Repo.Repository, ctx.Repo.GitRepo)
|
2023-03-28 20:22:07 +02:00
|
|
|
ctx.JSON(http.StatusOK, issueConfig)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ValidateIssueConfig returns validation errors for the issue config
|
|
|
|
func ValidateIssueConfig(ctx *context.APIContext) {
|
|
|
|
// swagger:operation GET /repos/{owner}/{repo}/issue_config/validate repository repoValidateIssueConfig
|
|
|
|
// ---
|
|
|
|
// summary: Returns the validation information for a issue config
|
|
|
|
// 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/RepoIssueConfigValidation"
|
2023-09-13 04:37:54 +02:00
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
2023-05-09 01:30:14 +02:00
|
|
|
_, err := issue.GetTemplateConfigFromDefaultBranch(ctx.Repo.Repository, ctx.Repo.GitRepo)
|
2023-03-28 20:22:07 +02:00
|
|
|
|
|
|
|
if err == nil {
|
|
|
|
ctx.JSON(http.StatusOK, api.IssueConfigValidation{Valid: true, Message: ""})
|
|
|
|
} else {
|
|
|
|
ctx.JSON(http.StatusOK, api.IssueConfigValidation{Valid: false, Message: err.Error()})
|
|
|
|
}
|
|
|
|
}
|
2023-04-04 15:35:31 +02:00
|
|
|
|
|
|
|
func ListRepoActivityFeeds(ctx *context.APIContext) {
|
|
|
|
// swagger:operation GET /repos/{owner}/{repo}/activities/feeds repository repoListActivityFeeds
|
|
|
|
// ---
|
|
|
|
// summary: List a repository's activity feeds
|
|
|
|
// 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: date
|
|
|
|
// in: query
|
|
|
|
// description: the date of the activities to be found
|
|
|
|
// type: string
|
|
|
|
// format: date
|
|
|
|
// - 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/ActivityFeedsList"
|
|
|
|
// "404":
|
|
|
|
// "$ref": "#/responses/notFound"
|
|
|
|
|
|
|
|
listOptions := utils.GetListOptions(ctx)
|
|
|
|
|
|
|
|
opts := activities_model.GetFeedsOptions{
|
|
|
|
RequestedRepo: ctx.Repo.Repository,
|
|
|
|
Actor: ctx.Doer,
|
|
|
|
IncludePrivate: true,
|
|
|
|
Date: ctx.FormString("date"),
|
|
|
|
ListOptions: listOptions,
|
|
|
|
}
|
|
|
|
|
|
|
|
feeds, count, err := activities_model.GetFeeds(ctx, opts)
|
|
|
|
if err != nil {
|
|
|
|
ctx.Error(http.StatusInternalServerError, "GetFeeds", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.SetTotalCountHeader(count)
|
|
|
|
|
|
|
|
ctx.JSON(http.StatusOK, convert.ToActivities(ctx, feeds, ctx.Doer))
|
|
|
|
}
|