2014-08-26 06:11:15 -04:00
// Copyright 2014 The Gogs Authors. All rights reserved.
2018-11-28 06:26:14 -05:00
// Copyright 2018 The Gitea Authors. All rights reserved.
2022-11-27 13:20:29 -05:00
// SPDX-License-Identifier: MIT
2014-08-26 06:11:15 -04:00
2015-12-04 17:16:42 -05:00
package repo
2014-08-26 06:11:15 -04:00
import (
2017-08-16 21:31:34 -04:00
"fmt"
2017-10-26 17:16:13 -04:00
"net/http"
2023-09-07 05:37:47 -04:00
"slices"
2017-02-10 23:00:01 -05:00
"strings"
2021-01-02 18:47:47 -05:00
"time"
2014-08-26 06:11:15 -04:00
2023-04-04 09:35:31 -04:00
activities_model "code.gitea.io/gitea/models/activities"
2021-11-24 04:49:20 -05:00
"code.gitea.io/gitea/models/db"
2022-03-29 02:29:02 -04:00
"code.gitea.io/gitea/models/organization"
2021-11-28 06:58:28 -05:00
"code.gitea.io/gitea/models/perm"
2022-05-11 06:09:36 -04:00
access_model "code.gitea.io/gitea/models/perm/access"
2021-12-09 20:27:50 -05:00
repo_model "code.gitea.io/gitea/models/repo"
2021-11-09 14:57:58 -05:00
unit_model "code.gitea.io/gitea/models/unit"
2021-11-24 04:49:20 -05:00
user_model "code.gitea.io/gitea/models/user"
2019-11-17 01:30:01 -05: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 15:09:51 -05:00
"code.gitea.io/gitea/modules/gitrepo"
2023-03-01 18:44:23 -05:00
"code.gitea.io/gitea/modules/label"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/log"
2024-02-29 13:52:49 -05:00
"code.gitea.io/gitea/modules/optional"
2022-04-22 13:19:55 -04:00
repo_module "code.gitea.io/gitea/modules/repository"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/setting"
2019-08-23 12:40:30 -04:00
api "code.gitea.io/gitea/modules/structs"
2019-10-02 05:30:41 -04:00
"code.gitea.io/gitea/modules/validation"
2021-01-26 10:36:53 -05:00
"code.gitea.io/gitea/modules/web"
2020-01-24 14:00:29 -05:00
"code.gitea.io/gitea/routers/api/v1/utils"
2024-02-27 02:12:22 -05:00
"code.gitea.io/gitea/services/context"
2022-12-28 21:57:15 -05:00
"code.gitea.io/gitea/services/convert"
2023-05-08 19:30:14 -04:00
"code.gitea.io/gitea/services/issue"
2019-10-26 02:54:11 -04: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 06:18:53 -05:00
wiki_service "code.gitea.io/gitea/services/wiki"
2014-08-26 06:11:15 -04:00
)
2016-11-24 02:04:31 -05:00
// Search repositories via options
2016-03-13 18:49:16 -04:00
func Search ( ctx * context . APIContext ) {
2017-11-13 02:02:25 -05: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-23 23:17:10 -04:00
// - name: topic
// in: query
// description: Limit search to repositories with keyword as topic
// type: boolean
2019-08-25 13:06:36 -04:00
// - name: includeDesc
// in: query
// description: include search of keyword within repository description
// type: boolean
2017-11-13 02:02:25 -05:00
// - name: uid
// in: query
2017-11-15 03:10:26 -05:00
// description: search only for repos that the user with the given id owns or contributes to
// type: integer
2018-10-20 23:40:42 -04:00
// format: int64
2019-11-11 10:15:29 -05:00
// - name: priority_owner_id
// in: query
// description: repo owner to prioritize in the results
// type: integer
// format: int64
2020-12-27 14:58:03 -05: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 11:24:39 -04: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-20 21:15:30 -04:00
// - name: is_private
2020-05-16 16:07:01 -04:00
// in: query
2020-05-20 21:15:30 -04:00
// description: show only pubic, private or all repositories (defaults to all)
2020-05-16 16:07:01 -04:00
// type: boolean
2019-11-11 10:15:29 -05:00
// - name: template
// in: query
// description: include template repositories this user has access to (defaults to true)
// type: boolean
2020-05-16 16:07:01 -04:00
// - name: archived
// in: query
// description: show only archived, non-archived or all repositories (defaults to all)
// type: boolean
2017-11-13 02:02:25 -05: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 03:10:26 -05:00
// description: if `uid` is given, search only for repos that the user owns
2017-11-13 02:02:25 -05:00
// type: boolean
2018-08-02 04:10:02 -04: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 14:00:29 -05:00
// - name: page
// in: query
// description: page number of results to return (1-based)
// type: integer
// - name: limit
// in: query
2020-06-09 00:57:38 -04:00
// description: page size of results
2020-01-24 14:00:29 -05:00
// type: integer
2017-11-13 02:02:25 -05:00
// responses:
// "200":
// "$ref": "#/responses/SearchResults"
// "422":
// "$ref": "#/responses/validationError"
2019-12-20 12:07:12 -05:00
2022-06-06 04:01:49 -04:00
opts := & repo_model . SearchRepoOptions {
2020-01-24 14:00:29 -05:00
ListOptions : utils . GetListOptions ( ctx ) ,
2022-03-22 03:03:22 -04:00
Actor : ctx . Doer ,
2021-08-11 11:08:52 -04:00
Keyword : ctx . FormTrim ( "q" ) ,
2021-07-28 21:42:15 -04:00
OwnerID : ctx . FormInt64 ( "uid" ) ,
PriorityOwnerID : ctx . FormInt64 ( "priority_owner_id" ) ,
TeamID : ctx . FormInt64 ( "team_id" ) ,
TopicOnly : ctx . FormBool ( "topic" ) ,
2024-02-29 13:52:49 -05:00
Collaborate : optional . None [ bool ] ( ) ,
2021-08-10 20:31:13 -04:00
Private : ctx . IsSigned && ( ctx . FormString ( "private" ) == "" || ctx . FormBool ( "private" ) ) ,
2024-02-29 13:52:49 -05:00
Template : optional . None [ bool ] ( ) ,
2021-07-28 21:42:15 -04:00
StarredByID : ctx . FormInt64 ( "starredBy" ) ,
IncludeDescription : ctx . FormBool ( "includeDesc" ) ,
2017-10-26 17:16:13 -04:00
}
2021-08-10 20:31:13 -04:00
if ctx . FormString ( "template" ) != "" {
2024-02-29 13:52:49 -05:00
opts . Template = optional . Some ( ctx . FormBool ( "template" ) )
2019-11-11 10:15:29 -05:00
}
2021-07-28 21:42:15 -04:00
if ctx . FormBool ( "exclusive" ) {
2024-02-29 13:52:49 -05:00
opts . Collaborate = optional . Some ( false )
2017-10-26 17:16:13 -04:00
}
2022-01-20 12:46:10 -05:00
mode := ctx . FormString ( "mode" )
2017-10-26 17:16:13 -04:00
switch mode {
case "source" :
2024-02-29 13:52:49 -05:00
opts . Fork = optional . Some ( false )
opts . Mirror = optional . Some ( false )
2017-10-26 17:16:13 -04:00
case "fork" :
2024-02-29 13:52:49 -05:00
opts . Fork = optional . Some ( true )
2017-10-26 17:16:13 -04:00
case "mirror" :
2024-02-29 13:52:49 -05:00
opts . Mirror = optional . Some ( true )
2017-10-26 17:16:13 -04:00
case "collaborative" :
2024-02-29 13:52:49 -05:00
opts . Mirror = optional . Some ( false )
opts . Collaborate = optional . Some ( true )
2017-10-26 17:16:13 -04:00
case "" :
default :
ctx . Error ( http . StatusUnprocessableEntity , "" , fmt . Errorf ( "Invalid search mode: \"%s\"" , mode ) )
return
2014-08-26 06:11:15 -04:00
}
2021-08-10 20:31:13 -04:00
if ctx . FormString ( "archived" ) != "" {
2024-02-29 13:52:49 -05:00
opts . Archived = optional . Some ( ctx . FormBool ( "archived" ) )
2020-05-16 16:07:01 -04:00
}
2021-08-10 20:31:13 -04:00
if ctx . FormString ( "is_private" ) != "" {
2024-02-29 13:52:49 -05:00
opts . IsPrivate = optional . Some ( ctx . FormBool ( "is_private" ) )
2020-05-20 21:15:30 -04:00
}
2022-01-20 12:46:10 -05:00
sortMode := ctx . FormString ( "sort" )
2018-08-02 04:10:02 -04:00
if len ( sortMode ) > 0 {
2022-01-20 12:46:10 -05:00
sortOrder := ctx . FormString ( "order" )
2018-08-02 04:10:02 -04:00
if len ( sortOrder ) == 0 {
sortOrder = "asc"
}
2023-05-08 05:36:54 -04:00
if searchModeMap , ok := repo_model . SearchOrderByMap [ sortOrder ] ; ok {
2018-08-02 04:10:02 -04: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 17:16:13 -04:00
var err error
2022-11-19 03:12:33 -05:00
repos , count , err := repo_model . SearchRepository ( ctx , opts )
2014-08-26 06:11:15 -04:00
if err != nil {
2019-12-20 12:07:12 -05:00
ctx . JSON ( http . StatusInternalServerError , api . SearchError {
2017-05-02 09:35:59 -04:00
OK : false ,
Error : err . Error ( ) ,
2014-08-26 06:11:15 -04:00
} )
return
}
2014-11-14 17:11:30 -05:00
results := make ( [ ] * api . Repository , len ( repos ) )
2017-02-09 20:30:26 -05:00
for i , repo := range repos {
2023-02-18 07:11:03 -05:00
if err = repo . LoadOwner ( ctx ) ; err != nil {
2019-12-20 12:07:12 -05:00
ctx . JSON ( http . StatusInternalServerError , api . SearchError {
2017-05-02 09:35:59 -04:00
OK : false ,
Error : err . Error ( ) ,
2014-08-26 06:11:15 -04:00
} )
return
}
2023-06-22 09:08:08 -04:00
permission , err := access_model . GetUserRepoPermission ( ctx , repo , ctx . Doer )
2017-02-09 20:30:26 -05:00
if err != nil {
2019-12-20 12:07:12 -05:00
ctx . JSON ( http . StatusInternalServerError , api . SearchError {
2017-05-02 09:35:59 -04:00
OK : false ,
Error : err . Error ( ) ,
2017-02-09 20:30:26 -05:00
} )
2014-08-26 06:11:15 -04:00
}
2023-06-22 09:08:08 -04:00
results [ i ] = convert . ToRepo ( ctx , repo , permission )
2014-08-26 06:11:15 -04:00
}
2020-01-24 14:00:29 -05:00
ctx . SetLinkHeader ( int ( count ) , opts . PageSize )
2021-08-12 08:43:08 -04:00
ctx . SetTotalCountHeader ( count )
2019-12-20 12:07:12 -05:00
ctx . JSON ( http . StatusOK , api . SearchResults {
2017-05-02 09:35:59 -04:00
OK : true ,
Data : results ,
2014-08-26 06:11:15 -04:00
} )
}
2014-08-28 23:24:37 -04:00
2016-11-24 02:04:31 -05:00
// CreateUserRepo create a repository for a user
2021-11-24 04:49:20 -05:00
func CreateUserRepo ( ctx * context . APIContext , owner * user_model . User , opt api . CreateRepoOption ) {
2019-02-21 17:07:58 -05:00
if opt . AutoInit && opt . Readme == "" {
opt . Readme = "Default"
}
2023-03-13 17:55:30 -04:00
// If the readme template does not exist, a 400 will be returned.
2023-09-07 05:37:47 -04:00
if opt . AutoInit && len ( opt . Readme ) > 0 && ! slices . Contains ( repo_module . Readmes , opt . Readme ) {
2023-03-13 17:55:30 -04:00
ctx . Error ( http . StatusBadRequest , "" , fmt . Errorf ( "readme template does not exist, available templates: %v" , repo_module . Readmes ) )
return
}
2023-09-06 08:08:51 -04:00
repo , err := repo_service . CreateRepository ( ctx , ctx . Doer , owner , repo_service . CreateRepoOptions {
2023-12-17 06:56:08 -05: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 11:05:02 -05:00
ObjectFormatName : opt . ObjectFormatName ,
2015-08-28 06:33:09 -04:00
} )
2014-12-12 20:30:32 -05:00
if err != nil {
2021-12-12 10:48:20 -05:00
if repo_model . IsErrRepoAlreadyExist ( err ) {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusConflict , "" , "The repository with the same name already exists." )
2021-11-24 04:49:20 -05:00
} else if db . IsErrNameReserved ( err ) ||
2022-04-22 13:19:55 -04:00
db . IsErrNamePatternNotAllowed ( err ) ||
2023-03-01 18:44:23 -05:00
label . IsErrTemplateLoad ( err ) {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusUnprocessableEntity , "" , err )
2014-12-12 20:30:32 -05:00
} else {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusInternalServerError , "CreateRepository" , err )
2014-12-12 20:30:32 -05:00
}
return
}
2020-09-15 18:42:19 -04:00
// reload repo from db to get a real state after creation
2022-12-02 21:48:26 -05:00
repo , err = repo_model . GetRepositoryByID ( ctx , repo . ID )
2020-09-15 18:42:19 -04:00
if err != nil {
ctx . Error ( http . StatusInternalServerError , "GetRepositoryByID" , err )
}
2023-06-22 09:08:08 -04:00
ctx . JSON ( http . StatusCreated , convert . ToRepo ( ctx , repo , access_model . Permission { AccessMode : perm . AccessModeOwner } ) )
2014-12-12 20:30:32 -05:00
}
2016-10-07 13:17:27 -04:00
// Create one repository of mine
2021-01-26 10:36:53 -05:00
func Create ( ctx * context . APIContext ) {
2017-11-13 02:02:25 -05: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 17:55:30 -04:00
// "400":
// "$ref": "#/responses/error"
2019-05-30 11:09:05 -04:00
// "409":
// description: The repository with the same name already exists.
// "422":
// "$ref": "#/responses/validationError"
2021-01-26 10:36:53 -05:00
opt := web . GetForm ( ctx ) . ( * api . CreateRepoOption )
2022-03-22 03:03:22 -04:00
if ctx . Doer . IsOrganization ( ) {
2017-11-13 02:02:25 -05:00
// Shouldn't reach this condition, but just in case.
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusUnprocessableEntity , "" , "not allowed creating repository for organization" )
2014-12-12 20:30:32 -05:00
return
}
2022-03-22 03:03:22 -04:00
CreateUserRepo ( ctx , ctx . Doer , * opt )
2014-12-12 20:30:32 -05:00
}
2021-07-05 11:29:08 -04: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 03:03:22 -04:00
if ctx . Doer . IsOrganization ( ) {
2021-07-05 11:29:08 -04:00
ctx . Error ( http . StatusUnprocessableEntity , "" , "not allowed creating repository for organization" )
return
}
2024-02-28 08:40:36 -05:00
opts := repo_service . GenerateRepoOptions {
2023-07-21 00:32:47 -04: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 11:29:08 -04:00
}
if ! opts . IsValid ( ) {
ctx . Error ( http . StatusUnprocessableEntity , "" , "must select at least one template item" )
return
}
2022-03-22 03:03:22 -04:00
ctxUser := ctx . Doer
2021-07-05 11:29:08 -04:00
var err error
if form . Owner != ctxUser . Name {
2022-05-20 10:08:52 -04:00
ctxUser , err = user_model . GetUserByName ( ctx , form . Owner )
2021-07-05 11:29:08 -04:00
if err != nil {
2021-11-24 04:49:20 -05:00
if user_model . IsErrUserNotExist ( err ) {
2023-07-04 14:36:08 -04:00
ctx . JSON ( http . StatusNotFound , map [ string ] any {
2021-07-15 14:19:39 -04:00
"error" : "request owner `" + form . Owner + "` does not exist" ,
2021-07-05 11:29:08 -04:00
} )
return
}
2021-07-15 14:19:39 -04:00
ctx . Error ( http . StatusInternalServerError , "GetUserByName" , err )
return
}
2022-03-22 03:03:22 -04:00
if ! ctx . Doer . IsAdmin && ! ctxUser . IsOrganization ( ) {
2021-07-15 14:19:39 -04:00
ctx . Error ( http . StatusForbidden , "" , "Only admin can generate repository for other user." )
2021-07-05 11:29:08 -04:00
return
}
2022-03-22 03:03:22 -04:00
if ! ctx . Doer . IsAdmin {
2023-10-03 06:30:41 -04:00
canCreate , err := organization . OrgFromUser ( ctxUser ) . CanCreateOrgRepo ( ctx , ctx . Doer . ID )
2021-07-05 11:29:08 -04: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 17:17:51 -05:00
repo , err := repo_service . GenerateRepository ( ctx , ctx . Doer , ctxUser , ctx . Repo . Repository , opts )
2021-07-05 11:29:08 -04:00
if err != nil {
2021-12-12 10:48:20 -05:00
if repo_model . IsErrRepoAlreadyExist ( err ) {
2021-07-05 11:29:08 -04:00
ctx . Error ( http . StatusConflict , "" , "The repository with the same name already exists." )
2021-11-24 04:49:20 -05:00
} else if db . IsErrNameReserved ( err ) ||
db . IsErrNamePatternNotAllowed ( err ) {
2021-07-05 11:29:08 -04: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 09:08:08 -04:00
ctx . JSON ( http . StatusCreated , convert . ToRepo ( ctx , repo , access_model . Permission { AccessMode : perm . AccessModeOwner } ) )
2021-07-05 11:29:08 -04:00
}
2020-01-09 11:40:01 -05:00
// CreateOrgRepoDeprecated create one repository of the organization
2021-01-26 10:36:53 -05:00
func CreateOrgRepoDeprecated ( ctx * context . APIContext ) {
2020-01-09 11:40:01 -05:00
// swagger:operation POST /org/{org}/repos organization createOrgRepoDeprecated
2017-11-13 02:02:25 -05:00
// ---
// summary: Create a repository in an organization
2020-01-09 11:40:01 -05:00
// deprecated: true
2017-11-13 02:02:25 -05: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-12 22:37:54 -04:00
// "404":
// "$ref": "#/responses/notFound"
2019-12-20 12:07:12 -05:00
2021-01-26 10:36:53 -05:00
CreateOrgRepo ( ctx )
2020-01-09 11:40:01 -05:00
}
// CreateOrgRepo create one repository of the organization
2021-01-26 10:36:53 -05:00
func CreateOrgRepo ( ctx * context . APIContext ) {
2020-01-09 11:40:01 -05: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 17:55:30 -04:00
// "400":
// "$ref": "#/responses/error"
2020-01-09 11:40:01 -05:00
// "404":
// "$ref": "#/responses/notFound"
// "403":
// "$ref": "#/responses/forbidden"
2021-01-26 10:36:53 -05:00
opt := web . GetForm ( ctx ) . ( * api . CreateRepoOption )
2023-02-08 01:44:42 -05:00
org , err := organization . GetOrgByName ( ctx , ctx . Params ( ":org" ) )
2014-12-12 20:30:32 -05:00
if err != nil {
2022-03-29 02:29:02 -04:00
if organization . IsErrOrgNotExist ( err ) {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusUnprocessableEntity , "" , err )
2014-12-12 20:30:32 -05:00
} else {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusInternalServerError , "GetOrgByName" , err )
2014-12-12 20:30:32 -05:00
}
return
}
2022-03-29 02:29:02 -04:00
if ! organization . HasOrgOrUserVisible ( ctx , org . AsUser ( ) , ctx . Doer ) {
2021-06-26 15:53:14 -04:00
ctx . NotFound ( "HasOrgOrUserVisible" , nil )
2019-02-18 11:00:27 -05:00
return
}
2022-03-22 03:03:22 -04:00
if ! ctx . Doer . IsAdmin {
2023-10-03 06:30:41 -04:00
canCreate , err := org . CanCreateOrgRepo ( ctx , ctx . Doer . ID )
2018-07-04 19:51:02 -04:00
if err != nil {
2020-09-20 16:20:14 -04:00
ctx . Error ( http . StatusInternalServerError , "CanCreateOrgRepo" , err )
2018-07-04 19:51:02 -04:00
return
2019-11-20 06:27:49 -05:00
} else if ! canCreate {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusForbidden , "" , "Given user is not allowed to create repository in organization." )
2018-07-04 19:51:02 -04:00
return
}
2014-12-12 20:30:32 -05:00
}
2021-11-19 06:41:40 -05:00
CreateUserRepo ( ctx , org . AsUser ( ) , * opt )
2014-12-12 20:30:32 -05:00
}
2016-10-07 13:17:27 -04:00
// Get one repository
2016-03-13 18:49:16 -04:00
func Get ( ctx * context . APIContext ) {
2017-11-13 02:02:25 -05: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-12 22:37:54 -04:00
// "404":
// "$ref": "#/responses/notFound"
2019-12-20 12:07:12 -05:00
2022-01-25 01:33:40 -05:00
if err := ctx . Repo . Repository . LoadAttributes ( ctx ) ; err != nil {
ctx . Error ( http . StatusInternalServerError , "Repository.LoadAttributes" , err )
return
}
2023-06-22 09:08:08 -04:00
ctx . JSON ( http . StatusOK , convert . ToRepo ( ctx , ctx . Repo . Repository , ctx . Repo . Permission ) )
2015-10-22 17:46:07 -04:00
}
2016-10-03 06:35:42 -04:00
// GetByID returns a single Repository
func GetByID ( ctx * context . APIContext ) {
2017-11-13 02:02:25 -05: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-20 23:40:42 -04:00
// format: int64
2017-11-13 02:02:25 -05:00
// required: true
// responses:
// "200":
// "$ref": "#/responses/Repository"
2023-09-12 22:37:54 -04:00
// "404":
// "$ref": "#/responses/notFound"
2019-12-20 12:07:12 -05:00
2022-12-02 21:48:26 -05:00
repo , err := repo_model . GetRepositoryByID ( ctx , ctx . ParamsInt64 ( ":id" ) )
2016-10-03 06:35:42 -04:00
if err != nil {
2021-12-09 20:27:50 -05:00
if repo_model . IsErrRepoNotExist ( err ) {
2019-03-18 22:29:43 -04:00
ctx . NotFound ( )
2016-10-03 06:35:42 -04:00
} else {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusInternalServerError , "GetRepositoryByID" , err )
2016-10-03 06:35:42 -04:00
}
return
}
2023-06-22 09:08:08 -04:00
permission , err := access_model . GetUserRepoPermission ( ctx , repo , ctx . Doer )
2016-12-05 18:48:51 -05:00
if err != nil {
2023-06-22 09:08:08 -04:00
ctx . Error ( http . StatusInternalServerError , "GetUserRepoPermission" , err )
2017-07-29 21:13:33 -04:00
return
2023-06-22 09:08:08 -04:00
} else if ! permission . HasAccess ( ) {
2019-03-18 22:29:43 -04:00
ctx . NotFound ( )
2016-12-05 18:48:51 -05:00
return
}
2023-06-22 09:08:08 -04:00
ctx . JSON ( http . StatusOK , convert . ToRepo ( ctx , repo , permission ) )
2016-10-03 06:35:42 -04:00
}
2019-05-30 11:09:05 -04:00
// Edit edit repository properties
2021-01-26 10:36:53 -05:00
func Edit ( ctx * context . APIContext ) {
2019-05-30 11:09:05 -04: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-12 22:37:54 -04:00
// "404":
// "$ref": "#/responses/notFound"
2019-05-30 11:09:05 -04:00
// "422":
// "$ref": "#/responses/validationError"
2019-12-20 12:07:12 -05:00
2021-01-26 10:36:53 -05:00
opts := * web . GetForm ( ctx ) . ( * api . EditRepoOption )
2019-05-30 11:09:05 -04: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 07:51:32 -05:00
if opts . MirrorInterval != nil || opts . EnablePrune != nil {
2022-04-20 04:20:53 -04:00
if err := updateMirror ( ctx , opts ) ; err != nil {
2021-01-02 18:47:47 -05:00
return
}
}
2022-12-02 21:48:26 -05:00
repo , err := repo_model . GetRepositoryByID ( ctx , ctx . Repo . Repository . ID )
2021-07-13 15:31:59 -04:00
if err != nil {
ctx . InternalServerError ( err )
return
}
2023-06-22 09:08:08 -04:00
ctx . JSON ( http . StatusOK , convert . ToRepo ( ctx , repo , ctx . Repo . Permission ) )
2019-05-30 11:09:05 -04: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 17:17:51 -05:00
if err := repo_service . ChangeRepositoryName ( ctx , ctx . Doer , repo , newRepoName ) ; err != nil {
2019-05-30 11:09:05 -04:00
switch {
2021-12-12 10:48:20 -05:00
case repo_model . IsErrRepoAlreadyExist ( err ) :
2019-05-30 11:09:05 -04:00
ctx . Error ( http . StatusUnprocessableEntity , fmt . Sprintf ( "repo name is already taken [name: %s]" , newRepoName ) , err )
2021-11-24 04:49:20 -05:00
case db . IsErrNameReserved ( err ) :
2019-05-30 11:09:05 -04:00
ctx . Error ( http . StatusUnprocessableEntity , fmt . Sprintf ( "repo name is reserved [name: %s]" , newRepoName ) , err )
2021-11-24 04:49:20 -05: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 11:09:05 -04: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-02 21:48:26 -05:00
if err := repo . GetBaseRepo ( ctx ) ; err != nil {
2021-03-11 13:09:52 -05:00
ctx . Error ( http . StatusInternalServerError , "Unable to load base repository" , err )
return err
}
2019-05-30 11:09:05 -04: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 03:03:22 -04:00
if visibilityChanged && setting . Repository . ForcePrivate && ! * opts . Private && ! ctx . Doer . IsAdmin {
2019-05-30 11:09:05 -04: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 10:15:29 -05:00
if opts . Template != nil {
repo . IsTemplate = * opts . Template
}
2021-05-08 08:11:36 -04:00
if ctx . Repo . GitRepo == nil && ! repo . IsEmpty {
2021-02-11 14:53:41 -05:00
var err error
2024-03-08 02:30:10 -05:00
ctx . Repo . GitRepo , err = gitrepo . OpenRepository ( ctx , repo )
2021-02-11 14:53:41 -05: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 08:11:36 -04:00
if opts . DefaultBranch != nil && repo . DefaultBranch != * opts . DefaultBranch && ( repo . IsEmpty || ctx . Repo . GitRepo . IsBranchExist ( * opts . DefaultBranch ) ) {
if ! repo . IsEmpty {
2024-03-08 02:30:10 -05:00
if err := gitrepo . SetDefaultBranch ( ctx , ctx . Repo . Repository , * opts . DefaultBranch ) ; err != nil {
2021-05-08 08:11:36 -04:00
if ! git . IsErrUnsupportedVersion ( err ) {
ctx . Error ( http . StatusInternalServerError , "SetDefaultBranch" , err )
return err
}
2019-11-17 01:30:01 -05: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 06:18:53 -05: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 17:17:51 -05:00
if err := repo_service . UpdateRepository ( ctx , repo , visibilityChanged ) ; err != nil {
2019-05-30 11:09:05 -04: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-09 20:27:50 -05:00
var units [ ] repo_model . RepoUnit
2021-11-09 14:57:58 -05:00
var deleteUnitTypes [ ] unit_model . Type
2019-05-30 11:09:05 -04:00
2022-12-09 21:46:31 -05:00
currHasIssues := repo . UnitEnabled ( ctx , unit_model . TypeIssues )
2022-09-27 18:23:58 -04:00
newHasIssues := currHasIssues
2020-01-17 02:34:37 -05:00
if opts . HasIssues != nil {
2022-09-27 18:23:58 -04:00
newHasIssues = * opts . HasIssues
}
if currHasIssues || newHasIssues {
if newHasIssues && opts . ExternalTracker != nil && ! unit_model . TypeExternalTracker . UnitGlobalDisabled ( ) {
2019-10-02 05:30:41 -04: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 11:09:05 -04:00
}
2019-10-02 05:30:41 -04:00
2021-12-09 20:27:50 -05:00
units = append ( units , repo_model . RepoUnit {
2019-10-02 05:30:41 -04:00
RepoID : repo . ID ,
2021-11-09 14:57:58 -05:00
Type : unit_model . TypeExternalTracker ,
2021-12-09 20:27:50 -05:00
Config : & repo_model . ExternalTrackerConfig {
2022-10-07 08:49:30 -04:00
ExternalTrackerURL : opts . ExternalTracker . ExternalTrackerURL ,
ExternalTrackerFormat : opts . ExternalTracker . ExternalTrackerFormat ,
ExternalTrackerStyle : opts . ExternalTracker . ExternalTrackerStyle ,
ExternalTrackerRegexpPattern : opts . ExternalTracker . ExternalTrackerRegexpPattern ,
2019-10-02 05:30:41 -04:00
} ,
} )
2021-11-09 14:57:58 -05:00
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypeIssues )
2022-09-27 18:23:58 -04:00
} else if newHasIssues && opts . ExternalTracker == nil && ! unit_model . TypeIssues . UnitGlobalDisabled ( ) {
2019-10-02 05:30:41 -04:00
// Default to built-in tracker
2021-12-09 20:27:50 -05:00
var config * repo_model . IssuesConfig
2019-10-02 05:30:41 -04:00
if opts . InternalTracker != nil {
2021-12-09 20:27:50 -05:00
config = & repo_model . IssuesConfig {
2019-10-02 05:30:41 -04:00
EnableTimetracker : opts . InternalTracker . EnableTimeTracker ,
AllowOnlyContributorsToTrackTime : opts . InternalTracker . AllowOnlyContributorsToTrackTime ,
EnableDependencies : opts . InternalTracker . EnableIssueDependencies ,
}
2022-12-09 21:46:31 -05:00
} else if unit , err := repo . GetUnit ( ctx , unit_model . TypeIssues ) ; err != nil {
2019-10-02 05:30:41 -04:00
// Unit type doesn't exist so we make a new config file with default values
2021-12-09 20:27:50 -05:00
config = & repo_model . IssuesConfig {
2019-10-02 05:30:41 -04:00
EnableTimetracker : true ,
AllowOnlyContributorsToTrackTime : true ,
EnableDependencies : true ,
}
} else {
config = unit . IssuesConfig ( )
}
2021-12-09 20:27:50 -05:00
units = append ( units , repo_model . RepoUnit {
2019-10-02 05:30:41 -04:00
RepoID : repo . ID ,
2021-11-09 14:57:58 -05:00
Type : unit_model . TypeIssues ,
2019-10-02 05:30:41 -04:00
Config : config ,
} )
2021-11-09 14:57:58 -05:00
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypeExternalTracker )
2022-09-27 18:23:58 -04:00
} else if ! newHasIssues {
2021-11-09 14:57:58 -05:00
if ! unit_model . TypeExternalTracker . UnitGlobalDisabled ( ) {
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypeExternalTracker )
2020-01-17 02:34:37 -05:00
}
2021-11-09 14:57:58 -05:00
if ! unit_model . TypeIssues . UnitGlobalDisabled ( ) {
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypeIssues )
2020-01-17 02:34:37 -05:00
}
2019-05-30 11:09:05 -04:00
}
}
2022-12-09 21:46:31 -05:00
currHasWiki := repo . UnitEnabled ( ctx , unit_model . TypeWiki )
2022-09-27 18:23:58 -04:00
newHasWiki := currHasWiki
2020-01-17 02:34:37 -05:00
if opts . HasWiki != nil {
2022-09-27 18:23:58 -04:00
newHasWiki = * opts . HasWiki
}
if currHasWiki || newHasWiki {
if newHasWiki && opts . ExternalWiki != nil && ! unit_model . TypeExternalWiki . UnitGlobalDisabled ( ) {
2019-10-02 05:30:41 -04: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-09 20:27:50 -05:00
units = append ( units , repo_model . RepoUnit {
2019-10-02 05:30:41 -04:00
RepoID : repo . ID ,
2021-11-09 14:57:58 -05:00
Type : unit_model . TypeExternalWiki ,
2021-12-09 20:27:50 -05:00
Config : & repo_model . ExternalWikiConfig {
2019-10-02 05:30:41 -04:00
ExternalWikiURL : opts . ExternalWiki . ExternalWikiURL ,
} ,
} )
2021-11-09 14:57:58 -05:00
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypeWiki )
2022-09-27 18:23:58 -04:00
} else if newHasWiki && opts . ExternalWiki == nil && ! unit_model . TypeWiki . UnitGlobalDisabled ( ) {
2021-12-09 20:27:50 -05:00
config := & repo_model . UnitConfig { }
units = append ( units , repo_model . RepoUnit {
2019-10-02 05:30:41 -04:00
RepoID : repo . ID ,
2021-11-09 14:57:58 -05:00
Type : unit_model . TypeWiki ,
2019-10-02 05:30:41 -04:00
Config : config ,
} )
2021-11-09 14:57:58 -05:00
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypeExternalWiki )
2022-09-27 18:23:58 -04:00
} else if ! newHasWiki {
2021-11-09 14:57:58 -05:00
if ! unit_model . TypeExternalWiki . UnitGlobalDisabled ( ) {
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypeExternalWiki )
2020-01-17 02:34:37 -05:00
}
2021-11-09 14:57:58 -05:00
if ! unit_model . TypeWiki . UnitGlobalDisabled ( ) {
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypeWiki )
2020-01-17 02:34:37 -05:00
}
2019-10-02 05:30:41 -04:00
}
2019-05-30 11:09:05 -04:00
}
2022-12-09 21:46:31 -05:00
currHasPullRequests := repo . UnitEnabled ( ctx , unit_model . TypePullRequests )
2022-09-27 18:23:58 -04:00
newHasPullRequests := currHasPullRequests
2020-01-17 02:34:37 -05:00
if opts . HasPullRequests != nil {
2022-09-27 18:23:58 -04:00
newHasPullRequests = * opts . HasPullRequests
}
if currHasPullRequests || newHasPullRequests {
if newHasPullRequests && ! unit_model . TypePullRequests . UnitGlobalDisabled ( ) {
2020-01-17 02:34:37 -05: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-09 21:46:31 -05:00
unit , err := repo . GetUnit ( ctx , unit_model . TypePullRequests )
2021-12-09 20:27:50 -05:00
var config * repo_model . PullRequestsConfig
2020-01-17 02:34:37 -05:00
if err != nil {
// Unit type doesn't exist so we make a new config file with default values
2021-12-09 20:27:50 -05:00
config = & repo_model . PullRequestsConfig {
2021-07-12 19:26:25 -04:00
IgnoreWhitespaceConflicts : false ,
AllowMerge : true ,
AllowRebase : true ,
AllowRebaseMerge : true ,
AllowSquash : true ,
2024-02-12 17:37:23 -05:00
AllowFastForwardOnly : true ,
2021-07-12 19:26:25 -04:00
AllowManualMerge : true ,
AutodetectManualMerge : false ,
2022-03-04 03:30:49 -05:00
AllowRebaseUpdate : true ,
2021-07-12 19:26:25 -04:00
DefaultDeleteBranchAfterMerge : false ,
2021-12-09 20:27:50 -05:00
DefaultMergeStyle : repo_model . MergeStyleMerge ,
2023-02-13 01:09:52 -05:00
DefaultAllowMaintainerEdit : false ,
2020-01-17 02:34:37 -05:00
}
} else {
config = unit . PullRequestsConfig ( )
2019-05-30 11:09:05 -04:00
}
2020-01-17 02:34:37 -05: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 17:37:23 -05:00
if opts . AllowFastForwardOnly != nil {
config . AllowFastForwardOnly = * opts . AllowFastForwardOnly
}
2021-03-03 22:41:23 -05:00
if opts . AllowManualMerge != nil {
config . AllowManualMerge = * opts . AllowManualMerge
}
if opts . AutodetectManualMerge != nil {
config . AutodetectManualMerge = * opts . AutodetectManualMerge
}
2022-03-04 03:30:49 -05:00
if opts . AllowRebaseUpdate != nil {
config . AllowRebaseUpdate = * opts . AllowRebaseUpdate
}
2021-07-12 19:26:25 -04:00
if opts . DefaultDeleteBranchAfterMerge != nil {
config . DefaultDeleteBranchAfterMerge = * opts . DefaultDeleteBranchAfterMerge
}
2021-03-27 10:55:40 -04:00
if opts . DefaultMergeStyle != nil {
2021-12-09 20:27:50 -05:00
config . DefaultMergeStyle = repo_model . MergeStyle ( * opts . DefaultMergeStyle )
2021-03-27 10:55:40 -04:00
}
2023-02-13 01:09:52 -05:00
if opts . DefaultAllowMaintainerEdit != nil {
config . DefaultAllowMaintainerEdit = * opts . DefaultAllowMaintainerEdit
}
2019-08-10 05:32:46 -04:00
2021-12-09 20:27:50 -05:00
units = append ( units , repo_model . RepoUnit {
2020-01-17 02:34:37 -05:00
RepoID : repo . ID ,
2021-11-09 14:57:58 -05:00
Type : unit_model . TypePullRequests ,
2020-01-17 02:34:37 -05:00
Config : config ,
} )
2022-09-27 18:23:58 -04:00
} else if ! newHasPullRequests && ! unit_model . TypePullRequests . UnitGlobalDisabled ( ) {
2021-11-09 14:57:58 -05:00
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypePullRequests )
2020-01-17 02:34:37 -05:00
}
2019-05-30 11:09:05 -04:00
}
2021-11-09 14:57:58 -05:00
if opts . HasProjects != nil && ! unit_model . TypeProjects . UnitGlobalDisabled ( ) {
2020-08-16 23:07:38 -04:00
if * opts . HasProjects {
2021-12-09 20:27:50 -05:00
units = append ( units , repo_model . RepoUnit {
2020-08-16 23:07:38 -04:00
RepoID : repo . ID ,
2021-11-09 14:57:58 -05:00
Type : unit_model . TypeProjects ,
2020-08-16 23:07:38 -04:00
} )
} else {
2021-11-09 14:57:58 -05:00
deleteUnitTypes = append ( deleteUnitTypes , unit_model . TypeProjects )
2020-08-16 23:07:38 -04:00
}
}
2023-03-16 13:30:42 -04: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 05:39:06 -04:00
if len ( units ) + len ( deleteUnitTypes ) > 0 {
2024-01-22 10:07:17 -05:00
if err := repo_model . UpdateRepositoryUnits ( ctx , repo , units , deleteUnitTypes ) ; err != nil {
2023-05-06 05:39:06 -04:00
ctx . Error ( http . StatusInternalServerError , "UpdateRepositoryUnits" , err )
return err
}
2019-05-30 11:09:05 -04: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 10:39:12 -04:00
if err := repo_model . SetArchiveRepoState ( ctx , repo , * opts . Archived ) ; err != nil {
2019-05-30 11:09:05 -04:00
log . Error ( "Tried to archive a repo: %s" , err )
ctx . Error ( http . StatusInternalServerError , "ArchiveRepoState" , err )
return err
}
log . Trace ( "Repository was archived: %s/%s" , ctx . Repo . Owner . Name , repo . Name )
} else {
2023-09-16 10:39:12 -04:00
if err := repo_model . SetArchiveRepoState ( ctx , repo , * opts . Archived ) ; err != nil {
2019-05-30 11:09:05 -04:00
log . Error ( "Tried to un-archive a repo: %s" , err )
ctx . Error ( http . StatusInternalServerError , "ArchiveRepoState" , err )
return err
}
log . Trace ( "Repository was un-archived: %s/%s" , ctx . Repo . Owner . Name , repo . Name )
}
}
return nil
}
2022-04-20 04:20:53 -04:00
// updateMirror updates a repo's mirror Interval and EnablePrune
func updateMirror ( ctx * context . APIContext , opts api . EditRepoOption ) error {
2021-01-02 18:47:47 -05:00
repo := ctx . Repo . Repository
2022-04-20 04:20:53 -04: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 10:08:52 -04:00
mirror , err := repo_model . GetMirrorByRepoID ( ctx , repo . ID )
2022-04-20 04:20:53 -04:00
if err != nil {
log . Error ( "Failed to get mirror: %s" , err )
ctx . Error ( http . StatusInternalServerError , "MirrorInterval" , err )
return err
}
// update MirrorInterval
2021-01-02 18:47:47 -05:00
if opts . MirrorInterval != nil {
2022-04-20 04:20:53 -04:00
// MirrorInterval should be a duration
interval , err := time . ParseDuration ( * opts . MirrorInterval )
2021-12-09 20:27:50 -05:00
if err != nil {
2022-04-20 04:20:53 -04:00
log . Error ( "Wrong format for MirrorInternal Sent: %s" , err )
ctx . Error ( http . StatusUnprocessableEntity , "MirrorInterval" , err )
2021-01-02 18:47:47 -05:00
return err
}
2022-04-20 04:20:53 -04: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-02 18:47:47 -05:00
ctx . Error ( http . StatusUnprocessableEntity , "MirrorInterval" , err )
return err
}
2022-04-20 04:20:53 -04: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-02 18:47:47 -05:00
}
2022-04-20 04:20:53 -04: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 10:08:52 -04:00
if err := repo_model . UpdateMirror ( ctx , mirror ) ; err != nil {
2022-04-20 04:20:53 -04:00
log . Error ( "Failed to Set Mirror Interval: %s" , err )
ctx . Error ( http . StatusUnprocessableEntity , "MirrorInterval" , err )
return err
}
2021-01-02 18:47:47 -05:00
return nil
}
2016-10-07 13:17:27 -04:00
// Delete one repository
2016-03-13 18:49:16 -04:00
func Delete ( ctx * context . APIContext ) {
2017-11-13 02:02:25 -05: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-12 22:37:54 -04:00
// "404":
// "$ref": "#/responses/notFound"
2019-12-20 12:07:12 -05:00
2016-11-14 17:33:58 -05:00
owner := ctx . Repo . Owner
repo := ctx . Repo . Repository
2015-10-04 11:09:16 -04:00
2023-09-25 09:17:37 -04:00
canDelete , err := repo_module . CanUserDelete ( ctx , repo , ctx . Doer )
2019-10-26 02:54:11 -04:00
if err != nil {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusInternalServerError , "CanUserDelete" , err )
2019-10-26 02:54:11 -04:00
return
} else if ! canDelete {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusForbidden , "" , "Given user is not owner of organization." )
2019-10-26 02:54:11 -04:00
return
2015-10-04 11:09:16 -04:00
}
2021-05-14 16:19:38 -04:00
if ctx . Repo . GitRepo != nil {
ctx . Repo . GitRepo . Close ( )
}
2022-03-22 03:03:22 -04:00
if err := repo_service . DeleteRepository ( ctx , ctx . Doer , repo , true ) ; err != nil {
2019-12-20 12:07:12 -05:00
ctx . Error ( http . StatusInternalServerError , "DeleteRepository" , err )
2015-10-04 11:09:16 -04:00
return
}
2015-10-22 17:46:07 -04:00
log . Trace ( "Repository deleted: %s/%s" , owner . Name , repo . Name )
2019-12-20 12:07:12 -05:00
ctx . Status ( http . StatusNoContent )
2015-10-04 11:09:16 -04:00
}
2020-09-11 10:48:39 -04: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-12 22:37:54 -04: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 06:42:52 -05:00
ret , _ := issue . GetTemplatesFromDefaultBranch ( ctx . Repo . Repository , ctx . Repo . GitRepo )
2023-05-08 19:30:14 -04:00
ctx . JSON ( http . StatusOK , ret )
2020-09-11 10:48:39 -04:00
}
2023-03-28 14:22:07 -04: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-12 22:37:54 -04:00
// "404":
// "$ref": "#/responses/notFound"
2023-05-08 19:30:14 -04:00
issueConfig , _ := issue . GetTemplateConfigFromDefaultBranch ( ctx . Repo . Repository , ctx . Repo . GitRepo )
2023-03-28 14:22:07 -04: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-12 22:37:54 -04:00
// "404":
// "$ref": "#/responses/notFound"
2023-05-08 19:30:14 -04:00
_ , err := issue . GetTemplateConfigFromDefaultBranch ( ctx . Repo . Repository , ctx . Repo . GitRepo )
2023-03-28 14:22:07 -04: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 09:35:31 -04: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 ) )
}