Add chinese documentations for Packages (#24914 ) (#25016 )

backport: #24914
Add chinese documentations for installation (#24904 ) (#25015 )
2025-08-16 00:03:31 -04:00 · 2023-05-31 15:55:01 +08:00 · 2023-05-31 14:17:19 +08:00 · 2023-05-31 14:12:37 +08:00
48 changed files with 5894 additions and 14 deletions
--- a/docs/content/doc/administration/adding-legal-pages.zh-cn.md
+++ b/docs/content/doc/administration/adding-legal-pages.zh-cn.md
@ -0,0 +1,40 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "添加法律页面"
 slug: adding-legal-pages
 weight: 110
 toc: false
 draft: false
 aliases:
  - /zh-cn/adding-legal-pages
 menu:
  sidebar:
    parent: "administration"
    name: "添加法律页面"
    identifier: "adding-legal-pages"
    weight: 110
 ---
 一些法域（例如欧盟）要求在网站上添加特定的法律页面（例如隐私政策）。按照以下步骤将它们添加到你的 Gitea 实例中。
 ## 获取页面
 Gitea 源代码附带了示例页面，位于 `contrib/legal` 目录中。将它们复制到 `custom/public/` 目录下。例如，如果要添加隐私政策：
 ```
 wget -O /path/to/custom/public/privacy.html https://raw.githubusercontent.com/go-gitea/gitea/main/contrib/legal/privacy.html.sample
 ```
 现在，你需要编辑该页面以满足你的需求。特别是，你必须更改电子邮件地址、网址以及与 "Your Gitea Instance" 相关的引用，以匹配你的情况。
 请务必不要放置会暗示 Gitea 项目对你的服务器负责的一般服务条款或隐私声明。
 ## 使其可见
 创建或追加到 `/path/to/custom/templates/custom/extra_links_footer.tmpl` 文件中：
 ```go
 <a class="item" href="{{AppSubUrl}}/assets/privacy.html">隐私政策</a>
 ```
 重启 Gitea 以查看更改。
--- a/docs/content/doc/administration/cmd-embedded.zh-cn.md
+++ b/docs/content/doc/administration/cmd-embedded.zh-cn.md
@ -0,0 +1,105 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "嵌入资源提取工具"
 slug: "cmd-embedded"
 weight: 20
 toc: false
 draft: false
 aliases:
  - /zh-cn/cmd-embedded
 menu:
  sidebar:
    parent: "administration"
    name: "嵌入资源提取工具"
    weight: 20
    identifier: "cmd-embedded"
 ---
 # 嵌入资源提取工具
 **目录**
 {{< toc >}}
 Gitea 的可执行文件包含了运行所需的所有资源：模板、图片、样式表和翻译文件。你可以通过在 `custom` 目录下的相应路径中放置替换文件来覆盖其中的任何资源（详见 [自定义 Gitea 配置]({{< relref "doc/administration/customizing-gitea.zh-cn.md" >}})）。
 要获取嵌入资源的副本以进行编辑，可以使用 CLI 中的 `embedded` 命令，通过操作系统的 shell 执行。
 **注意：** 嵌入资源提取工具包含在 Gitea 1.12 及以上版本中。
 ## 资源列表
 要列出嵌入在 Gitea 可执行文件中的资源，请使用以下语法：
 ```sh
 gitea embedded list [--include-vendored] [patterns...]
 ```
 `--include-vendored` 标志使命令包括被供应的文件，这些文件通常被排除在外；即来自外部库的文件，这些文件是 Gitea 所需的（例如 [octicons](https://octicons.github.com/) 等）。
 可以提供一系列文件搜索模式。Gitea 使用 [gobwas/glob](https://github.com/gobwas/glob) 作为其 glob 语法。以下是一些示例：
 - 列出所有模板文件，无论在哪个虚拟目录下：`**.tmpl`
 - 列出所有邮件模板文件：`templates/mail/**.tmpl`
 - 列出 `public/img` 目录下的所有文件：`public/img/**`
 不要忘记为模式使用引号，因为空格、`*` 和其他字符可能对命令行解释器有特殊含义。
 如果未提供模式，则列出所有文件。
 ### 示例
 列出所有路径中包含 `openid` 的嵌入文件：
 ```sh
 $ gitea embedded list '**openid**'
 public/img/auth/openid_connect.svg
 public/img/openid-16x16.png
 templates/user/auth/finalize_openid.tmpl
 templates/user/auth/signin_openid.tmpl
 templates/user/auth/signup_openid_connect.tmpl
 templates/user/auth/signup_openid_navbar.tmpl
 templates/user/auth/signup_openid_register.tmpl
 templates/user/settings/security_openid.tmpl
 ```
 ## 提取资源
 要提取嵌入在 Gitea 可执行文件中的资源，请使用以下语法：
 ```sh
 gitea [--config {file}] embedded extract [--destination {dir}|--custom] [--overwrite|--rename] [--include-vendored] {patterns...}
 ```
 `--config` 选项用于告知 Gitea `app.ini` 配置文件的位置（如果不在默认位置）。此选项仅在使用 `--custom` 标志时使用。
 `--destination` 选项用于指定提取文件的目标目录。默认为当前目录。
 `--custom` 标志告知 Gitea 直接将文件提取到 `custom` 目录中。为使其正常工作，该命令需要知道 `app.ini` 配置文件的位置（通过 `--config` 指定），并且根据配置的不同，需要从 Gitea 通常启动的目录运行。有关详细信息，请参阅 [自定义 Gitea 配置]({{< relref "doc/administration/customizing-gitea.zh-cn.md" >}})。
 `--overwrite` 标志允许覆盖目标目录中的任何现有文件。
 `--rename` 标志告知 Gitea 将目标目录中的任何现有文件重命名为 `filename.bak`。之前的 `.bak` 文件将被覆盖。
 至少需要提供一个文件搜索模式；有关模式的语法和示例，请参阅上述 `list` 子命令。
 ### 重要提示
 请确保**只提取需要自定义的文件**。位于 `custom` 目录中的文件不会受到 Gitea 的升级过程的影响。当 Gitea 升级到新版本（通过替换可执行文件）时，许多嵌入文件将发生变化。Gitea 将尊重并使用在 `custom` 目录中找到的任何文件，即使这些文件是旧的和不兼容的。
 ### 示例
 将邮件模板提取到临时目录：
 ```sh
 $ mkdir tempdir
 $ gitea embedded extract --destination tempdir 'templates/mail/**.tmpl'
 Extracting to tempdir:
 tempdir/templates/mail/auth/activate.tmpl
 tempdir/templates/mail/auth/activate_email.tmpl
 tempdir/templates/mail/auth/register_notify.tmpl
 tempdir/templates/mail/auth/reset_passwd.tmpl
 tempdir/templates/mail/issue/assigned.tmpl
 tempdir/templates/mail/issue/default.tmpl
 tempdir/templates/mail/notify/collaborator.tmpl
 ```
--- a/docs/content/doc/administration/command-line.zh-cn.md
+++ b/docs/content/doc/administration/command-line.zh-cn.md
@ -0,0 +1,556 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "Gitea 命令行"
 slug: "command-line"
 weight: 1
 toc: false
 draft: false
 aliases:
  - /zh-cn/command-line
 menu:
  sidebar:
    parent: "administration"
    name: "Gitea 命令行"
    weight: 1
    identifier: "command-line"
 ---
 # 命令行
 **目录**
 {{< toc >}}
 ## 用法
 `gitea [全局选项] 命令 [命令或全局选项] [参数...]`
 ## 全局选项
 所有全局选项均可被放置在命令级别。
 - `--help`，`-h`：显示帮助文本并退出。可选。
 - `--version`，`-v`：显示版本信息并退出。可选。 (示例：`Gitea version 1.1.0+218-g7b907ed built with: bindata, sqlite`)。
 - `--custom-path path`，`-C path`：Gitea 自定义文件夹的路径。可选。 (默认值：`AppWorkPath`/custom 或 `$GITEA_CUSTOM`)。
 - `--config path`，`-c path`：Gitea 配置文件的路径。可选。 (默认值：`custom`/conf/app.ini)。
 - `--work-path path`，`-w path`：Gitea 的 `AppWorkPath`。可选。 (默认值：LOCATION_OF_GITEA_BINARY 或 `$GITEA_WORK_DIR`)
 注意：默认的 custom-path、config 和 work-path 也可以在构建时更改（如果需要）。
 ## 命令
 ### web
 启动服务器：
 - 选项：
  - `--port number`，`-p number`：端口号。可选。 (默认值：3000)。覆盖配置文件中的设置。
  - `--install-port number`：运行安装页面的端口号。可选。 (默认值：3000)。覆盖配置文件中的设置。
  - `--pid path`，`-P path`：Pid 文件的路径。可选。
  - `--quiet`，`-q`：只在控制台上输出 Fatal 日志，用于在设置日志之前发出的日志。
  - `--verbose`：在控制台上输出跟踪日志，用于在设置日志之前发出的日志。
 - 示例：
  - `gitea web`
  - `gitea web --port 80`
  - `gitea web --config /etc/gitea.ini --pid /some/custom/gitea.pid`
 - 注意：
  - Gitea 不应以 root 用户身份运行。要绑定到低于 1024 的端口，您可以在 Linux 上使用 setcap 命令：`sudo setcap 'cap_net_bind_service=+ep' /path/to/gitea`。每次更新 Gitea 都需要重新执行此操作。
 ### admin
 管理员操作：
 - 命令：
  - `user`：
    - `list`：
      - 选项：
        - `--admin`：仅列出管理员用户。可选。
      - 描述：列出所有现有用户。
      - 示例：
        - `gitea admin user list`
    - `delete`：
      - 选项：
        - `--email`：要删除的用户的电子邮件。
        - `--username`：要删除的用户的用户名。
        - `--id`：要删除的用户的ID。
        - 必须提供 `--id`、`--username` 或 `--email` 中的一个。如果提供多个，则所有条件必须匹配。
      - 示例：
        - `gitea admin user delete --id 1`
    - `create`：
      - 选项：
        - `--name value`：用户名。必填。自 Gitea 1.9.0 版本起，请改用 `--username` 标志。
        - `--username value`：用户名。必填。Gitea 1.9.0 新增。
        - `--password value`：密码。必填。
        - `--email value`：邮箱。必填。
        - `--admin`：如果提供此选项，将创建一个管理员用户。可选。
        - `--access-token`：如果提供，将为用户创建访问令牌。可选。（默认值：false）。
        - `--must-change-password`：如果提供，创建的用户将在初始登录后需要选择一个新密码。可选。（默认值：true）。
        - `--random-password`：如果提供，将使用随机生成的密码作为创建用户的密码。`--password` 的值将被忽略。可选。
        - `--random-password-length`：如果提供，将用于配置随机生成密码的长度。可选。（默认值：12）
      - 示例：
        - `gitea admin user create --username myname --password asecurepassword --email me@example.com`
    - `change-password`：
      - 选项：
        - `--username value`，`-u value`：用户名。必填。
        - `--password value`，`-p value`：新密码。必填。
      - 示例：
        - `gitea admin user change-password --username myname --password asecurepassword`
    - `must-change-password`：
      - 参数：
        - `[username...]`：需要更改密码的用户
      - 选项：
        - `--all`，`-A`：强制所有用户更改密码
        - `--exclude username`，`-e username`：排除给定的用户。可以多次设置。
        - `--unset`：撤销对给定用户的强制密码更改
  - `regenerate`：
    - 选项：
      - `hooks`：重新生成所有仓库的 Git Hooks。
      - `keys`：重新生成 authorized_keys 文件。
    - 示例：
      - `gitea admin regenerate hooks`
      - `gitea admin regenerate keys`
  - `auth`：
    - `list`：
      - 描述：列出所有存在的外部认证源。
      - 示例：
        - `gitea admin auth list`
    - `delete`：
      - 选项：
        - `--id`：要删除的源的 ID。必填。
      - 示例：
        - `gitea admin auth delete --id 1`
    - `add-oauth`：
      - 选项：
        - `--name`：应用程序名称。
        - `--provider`：OAuth2 提供者。
        - `--key`：客户端 ID（Key）。
        - `--secret`：客户端密钥。
        - `--auto-discover-url`：OpenID Connect 自动发现 URL（仅在使用 OpenID Connect 作为提供程序时需要）。
        - `--use-custom-urls`：在 GitLab/GitHub OAuth 端点上使用自定义 URL。
        - `--custom-tenant-id`：在 OAuth 端点上使用自定义租户 ID。
        - `--custom-auth-url`：使用自定义授权 URL（GitLab/GitHub 的选项）。
        - `--custom-token-url`：使用自定义令牌 URL（GitLab/GitHub 的选项）。
        - `--custom-profile-url`：使用自定义配置文件 URL（GitLab/GitHub 的选项）。
        - `--custom-email-url`：使用自定义电子邮件 URL（GitHub 的选项）。
        - `--icon-url`：OAuth2 登录源的自定义图标 URL。
        - `--skip-local-2fa`：允许源覆盖本地 2FA。（可选）
        - `--scopes`：请求此 OAuth2 源的附加范围。（可选）
        - `--required-claim-name`：必须设置的声明名称，以允许用户使用此源登录。（可选）
        - `--required-claim-value`：必须设置的声明值，以允许用户使用此源登录。（可选）
        - `--group-claim-name`：提供此源的组名的声明名称。（可选）
        - `--admin-group`：管理员用户的组声明值。（可选）
        - `--restricted-group`：受限用户的组声明值。（可选）
        - `--group-team-map`：组与组织团队之间的 JSON 映射。（可选）
        - `--group-team-map-removal`：根据组自动激活团队成员资格的删除。（可选）
      - 示例：
        - `gitea admin auth add-oauth --name external-github --provider github --key OBTAIN_FROM_SOURCE --secret OBTAIN_FROM_SOURCE`
    - `update-oauth`：
      - 选项：
        - `--id`：要更新的源的 ID。必填。
        - `--name`：应用程序名称。
        - `--provider`：OAuth2 提供者。
        - `--key`：客户端 ID（Key）。
        - `--secret`：客户端密钥。
        - `--auto-discover-url`：OpenID Connect 自动发现 URL（仅在使用 OpenID Connect 作为提供程序时需要）。
        - `--use-custom-urls`：在 GitLab/GitHub OAuth 端点上使用自定义 URL。
        - `--custom-tenant-id`：在 OAuth 端点上使用自定义租户 ID。
        - `--custom-auth-url`：使用自定义授权 URL（GitLab/GitHub 的选项）。
        - `--custom-token-url`：使用自定义令牌 URL（GitLab/GitHub 的选项）。
        - `--custom-profile-url`：使用自定义配置文件 URL（GitLab/GitHub 的选项）。
        - `--custom-email-url`：使用自定义电子邮件 URL（GitHub 的选项）。
        - `--icon-url`：OAuth2 登录源的自定义图标 URL。
        - `--skip-local-2fa`：允许源覆盖本地 2FA。（可选）
        - `--scopes`：请求此 OAuth2 源的附加范围。
        - `--required-claim-name`：必须设置的声明名称，以允许用户使用此源登录。（可选）
        - `--required-claim-value`：必须设置的声明值，以允许用户使用此源登录。（可选）
        - `--group-claim-name`：提供此源的组名的声明名称。（可选）
        - `--admin-group`：管理员用户的组声明值。（可选）
        - `--restricted-group`：受限用户的组声明值。（可选）
      - 示例：
        - `gitea admin auth update-oauth --id 1 --name external-github-updated`
    - `add-smtp`：
      - 选项：
        - `--name`：应用程序名称。必填。
        - `--auth-type`：SMTP 认证类型（PLAIN/LOGIN/CRAM-MD5）。默认为 PLAIN。
        - `--host`：SMTP 主机。必填。
        - `--port`：SMTP 端口。必填。
        - `--force-smtps`：SMTPS 始终在端口 465 上使用。设置此选项以强制在其他端口上使用 SMTPS。
        - `--skip-verify`：跳过 TLS 验证。
        - `--helo-hostname`：发送 HELO 时使用的主机名。留空以发送当前主机名。
        - `--disable-helo`：禁用 SMTP helo。
        - `--allowed-domains`：留空以允许所有域。使用逗号（','）分隔多个域。
        - `--skip-local-2fa`：跳过 2FA 登录。
        - `--active`：启用此认证源。
        备注：
        `--force-smtps`、`--skip-verify`、`--disable-helo`、`--skip-local-2fs` 和 `--active` 选项可以采用以下形式使用：
        - `--option`、`--option=true` 以启用选项
        - `--option=false` 以禁用选项
        如果未指定这些选项，则在 `update-smtp` 中不会更改值，或者在 `add-smtp` 中将使用默认的 `false` 值。
      - 示例：
        - `gitea admin auth add-smtp --name ldap --host smtp.mydomain.org --port 587 --skip-verify --active`
    - `update-smtp`：
      - 选项：
        - `--id`：要更新的源的 ID。必填。
        - 其他选项与 `add-smtp` 共享
      - 示例：
        - `gitea admin auth update-smtp --id 1 --host smtp.mydomain.org --port 587 --skip-verify=false`
        - `gitea admin auth update-smtp --id 1 --active=false`
    - `add-ldap`：添加新的 LDAP（通过 Bind DN）认证源
      - 选项：
        - `--name value`：认证名称。必填。
        - `--not-active`：停用认证源。
        - `--security-protocol value`：安全协议名称。必填。
        - `--skip-tls-verify`：禁用 TLS 验证。
        - `--host value`：LDAP 服务器的地址。必填。
        - `--port value`：连接到 LDAP 服务器时使用的端口。必填。
        - `--user-search-base value`：用户帐户将在其中搜索的 LDAP 基础路径。必填。
        - `--user-filter value`：声明如何查找试图进行身份验证的用户记录的 LDAP 过滤器。必填。
        - `--admin-filter value`：指定是否应授予用户管理员特权的 LDAP 过滤器。
        - `--restricted-filter value`：指定是否应将用户设置为受限状态的 LDAP 过滤器。
        - `--username-attribute value`：用户 LDAP 记录中包含用户名的属性。
        - `--firstname-attribute value`：用户 LDAP 记录中包含用户名字的属性。
        - `--surname-attribute value`：用户 LDAP 记录中包含用户姓氏的属性。
        - `--email-attribute value`：用户 LDAP 记录中包含用户电子邮件地址的属性。必填。
        - `--public-ssh-key-attribute value`：用户 LDAP 记录中包含用户公共 SSH 密钥的属性。
        - `--avatar-attribute value`：用户 LDAP 记录中包含用户头像的属性。
        - `--bind-dn value`：在搜索用户时绑定到 LDAP 服务器的 DN。
        - `--bind-password value`：绑定 DN 的密码（如果有）。
        - `--attributes-in-bind`：在绑定 DN 上下文中获取属性。
        - `--synchronize-users`：启用用户同步。
        - `--page-size value`：搜索页面大小。
      - 示例：
        - `gitea admin auth add-ldap --name ldap --security-protocol unencrypted --host mydomain.org --port 389 --user-search-base "ou=Users,dc=mydomain,dc=org" --user-filter "(&(objectClass=posixAccount)(|(uid=%[1]s)(mail=%[1]s)))" --email-attribute mail`
    - `update-ldap`：更新现有的 LDAP（通过 Bind DN）认证源
      - 选项：
        - `--id value`：认证源的 ID。必填。
        - `--name value`：认证名称。
        - `--not-active`：停用认证源。
        - `--security-protocol value`：安全协议名称。
        - `--skip-tls-verify`：禁用 TLS 验证。
        - `--host value`：LDAP 服务器的地址。
        - `--port value`：连接到 LDAP 服务器时使用的端口。
        - `--user-search-base value`：用户帐户将在其中搜索的 LDAP 基础路径。
        - `--user-filter value`：声明如何查找试图进行身份验证的用户记录的 LDAP 过滤器。
        - `--admin-filter value`：指定是否应授予用户管理员特权的 LDAP 过滤器。
        - `--restricted-filter value`：指定是否应将用户设置为受限状态的 LDAP 过滤器。
        - `--username-attribute value`：用户 LDAP 记录中包含用户名的属性。
        - `--firstname-attribute value`：用户 LDAP 记录中包含用户名字的属性。
        - `--surname-attribute value`：用户 LDAP 记录中包含用户姓氏的属性。
        - `--email-attribute value`：用户 LDAP 记录中包含用户电子邮件地址的属性。
        - `--public-ssh-key-attribute value`：用户 LDAP 记录中包含用户公共 SSH 密钥的属性。
        - `--avatar-attribute value`：用户 LDAP 记录中包含用户头像的属性。
        - `--bind-dn value`：在搜索用户时绑定到 LDAP 服务器的 DN。
        - `--bind-password value`：绑定 DN 的密码（如果有）。
        - `--attributes-in-bind`：在绑定 DN 上下文中获取属性。
        - `--synchronize-users`：启用用户同步。
        - `--page-size value`：搜索页面大小。
      - 示例：
        - `gitea admin auth update-ldap --id 1 --name "my ldap auth source"`
        - `gitea admin auth update-ldap --id 1 --username-attribute uid --firstname-attribute givenName --surname-attribute sn`
    - `add-ldap-simple`：添加新的 LDAP（简单身份验证）认证源
      - 选项：
        - `--name value`：认证名称。必填。
        - `--not-active`：停用认证源。
        - `--security-protocol value`：安全协议名称。必填。
        - `--skip-tls-verify`：禁用 TLS 验证。
        - `--host value`：LDAP 服务器的地址。必填。
        - `--port value`：连接到 LDAP 服务器时使用的端口。必填。
        - `--user-search-base value`：用户帐户将在其中搜索的 LDAP 基础路径。
        - `--user-filter value`：声明如何查找试图进行身份验证的用户记录的 LDAP 过滤器。必填。
        - `--admin-filter value`：指定是否应授予用户管理员特权的 LDAP 过滤器。
        - `--restricted-filter value`：指定是否应将用户设置为受限状态的 LDAP 过滤器。
        - `--username-attribute value`：用户 LDAP 记录中包含用户名的属性。
        - `--firstname-attribute value`：用户 LDAP 记录中包含用户名字的属性。
        - `--surname-attribute value`：用户 LDAP 记录中包含用户姓氏的属性。
        - `--email-attribute value`：用户 LDAP 记录中包含用户电子邮件地址的属性。必填。
        - `--public-ssh-key-attribute value`：用户 LDAP 记录中包含用户公共 SSH 密钥的属性。
        - `--avatar-attribute value`：用户 LDAP 记录中包含用户头像的属性。
        - `--user-dn value`：用户的 DN。必填。
      - 示例：
        - `gitea admin auth add-ldap-simple --name ldap --security-protocol unencrypted --host mydomain.org --port 389 --user-dn "cn=%s,ou=Users,dc=mydomain,dc=org" --user-filter "(&(objectClass=posixAccount)(cn=%s))" --email-attribute mail`
    - `update-ldap-simple`：更新现有的 LDAP（简单身份验证）认证源
      - 选项：
        - `--id value`：认证源的 ID。必填。
        - `--name value`：认证名称。
        - `--not-active`：停用认证源。
        - `--security-protocol value`：安全协议名称。
        - `--skip-tls-verify`：禁用 TLS 验证。
        - `--host value`：LDAP 服务器的地址。
        - `--port value`：连接到 LDAP 服务器时使用的端口。
        - `--user-search-base value`：用户帐户将在其中搜索的 LDAP 基础路径。
        - `--user-filter value`：声明如何查找试图进行身份验证的用户记录的 LDAP 过滤器。
        - `--admin-filter value`：指定是否应授予用户管理员特权的 LDAP 过滤器。
        - `--restricted-filter value`：指定是否应将用户设置为受限状态的 LDAP 过滤器。
        - `--username-attribute value`：用户 LDAP 记录中包含用户名的属性。
        - `--firstname-attribute value`：用户 LDAP 记录中包含用户名字的属性。
        - `--surname-attribute value`：用户 LDAP 记录中包含用户姓氏的属性。
        - `--email-attribute value`：用户 LDAP 记录中包含用户电子邮件地址的属性。
        - `--public-ssh-key-attribute value`：用户 LDAP 记录中包含用户公共 SSH 密钥的属性。
        - `--avatar-attribute value`：用户 LDAP 记录中包含用户头像的属性。
        - `--user-dn value`：用户的 DN。
      - 示例：
        - `gitea admin auth update-ldap-simple --id 1 --name "my ldap auth source"`
        - `gitea admin auth update-ldap-simple --id 1 --username-attribute uid --firstname-attribute givenName --surname-attribute sn`
 ### cert
 生成自签名的SSL证书。将输出到当前目录下的`cert.pem`和`key.pem`文件中，并且会覆盖任何现有文件。
 - 选项：
  - `--host value`：逗号分隔的主机名和IP地址列表，此证书适用于这些主机。支持使用通配符。必填。
  - `--ecdsa-curve value`：用于生成密钥的ECDSA曲线。可选。有效选项为P224、P256、P384、P521。
  - `--rsa-bits value`：要生成的RSA密钥的大小。可选。如果设置了--ecdsa-curve，则忽略此选项。（默认值：2048）。
  - `--start-date value`：证书的创建日期。可选。（格式：`Jan 1 15:04:05 2011`）。
  - `--duration value`：证书有效期。可选。（默认值：8760h0m0s）
  - `--ca`：如果提供此选项，则证书将生成自己的证书颁发机构。可选。
 - 示例：
  - `gitea cert --host git.example.com,example.com,www.example.com --ca`
 ### dump
 将所有文件和数据库导出到一个zip文件中。输出文件将保存在当前目录下，类似于`gitea-dump-1482906742.zip`。
 - 选项：
  - `--file name`，`-f name`：指定要创建的导出文件的名称。可选。（默认值：gitea-dump-[timestamp].zip）。
  - `--tempdir path`，`-t path`：指定临时目录的路径。可选。（默认值：/tmp）。
  - `--skip-repository`，`-R`：跳过仓库的导出。可选。
  - `--skip-custom-dir`：跳过自定义目录的导出。可选。
  - `--skip-lfs-data`：跳过LFS数据的导出。可选。
  - `--skip-attachment-data`：跳过附件数据的导出。可选。
  - `--skip-package-data`：跳过包数据的导出。可选。
  - `--skip-log`：跳过日志数据的导出。可选。
  - `--database`，`-d`：指定数据库的SQL语法。可选。
  - `--verbose`，`-V`：如果提供此选项，显示附加详细信息。可选。
  - `--type`：设置导出的格式。可选。（默认值：zip）
 - 示例：
  - `gitea dump`
  - `gitea dump --verbose`
 ### generate
 用于在配置文件中生成随机值和令牌。对于自动部署时生成值非常有用。
 - 命令:
  - `secret`:
    - 选项:
      - `INTERNAL_TOKEN`: 用于内部 API 调用身份验证的令牌。
      - `JWT_SECRET`: 用于 LFS 和 OAUTH2 JWT 身份验证的密钥（LFS_JWT_SECRET 是此选项的别名，用于向后兼容）。
      - `SECRET_KEY`: 全局密钥。
    - 示例:
      - `gitea generate secret INTERNAL_TOKEN`
      - `gitea generate secret JWT_SECRET`
      - `gitea generate secret SECRET_KEY`
 ### keys
 提供一个 SSHD AuthorizedKeysCommand。需要在 sshd 配置文件中进行配置:
 ```ini
 ...
 # -e 的值和 AuthorizedKeysCommandUser 应与运行 Gitea 的用户名匹配
 AuthorizedKeysCommandUser git
 AuthorizedKeysCommand /path/to/gitea keys -e git -u %u -t %t -k %k
 ```
 该命令将返回适用于提供的密钥的合适 authorized_keys 行。您还应在 `app.ini` 的 `[server]` 部分设置值 `SSH_CREATE_AUTHORIZED_KEYS_FILE=false`。
 注意: opensshd 要求 Gitea 程序由 root 拥有，并且不可由组或其他人写入。程序必须使用绝对路径指定。
 注意: Gitea 必须在运行此命令时处于运行状态才能成功。
 ### migrate
 迁移数据库。该命令可用于在首次启动服务器之前运行其他命令。此命令是幂等的。
 ### convert
 将现有的 MySQL 数据库从 utf8 转换为 utf8mb4。
 ### doctor
 根据给定的配置诊断当前 Gitea 实例的问题。目前有以下检查清单:
 - 检查 OpenSSH 的 authorized_keys 文件是否正确
  当您的 Gitea 实例支持 OpenSSH 时，当您的 Gitea 实例添加或更改任何公钥时，Gitea 实例的二进制路径将被写入 `authorized_keys` 文件。
  有时，如果您在升级时移动或重命名了 Gitea 二进制文件，并且您没有在管理面板上运行“使用 Gitea 的 SSH 密钥更新「.ssh/authorized_keys」文件”操作。那么通过 SSH 的所有拉取/推送操作将无法正常工作。
  此检查将帮助您检查它是否正常工作。
 对于贡献者，如果您想添加更多的检查项，您可以编写一个新的函数，如 `func(ctx *cli.Context) ([]string, error)`，并将其追加到 `doctor.go` 文件中。
 ```go
 var checklist = []check{
 	{
 		title: "Check if OpenSSH authorized_keys file id correct",
 		f:     runDoctorLocationMoved,
    },
    // more checks please append here
 }
 ```
 此函数将接收一个命令行上下文，并返回有关问题或错误的详细信息列表。
 #### doctor recreate-table
 有时，在迁移时，旧的列和默认值可能会在数据库模式中保持不变。这可能会导致警告，如下所示:
 ```
 2020/08/02 11:32:29 ...rm/session_schema.go:360:Sync2() [W] Table user Column keep_activity_private db default is , struct default is 0
 ```
 您可以通过以下方式让 Gitea 重新创建这些表，并将旧数据复制到新表中，并适当设置默认值：
 ```
 gitea doctor recreate-table user
 ```
 您可以使用以下方式让 Gitea 重新创建多个表：
 ```
 gitea doctor recreate-table table1 table2 ...
 ```
 如果您希望 Gitea 重新创建所有表，请直接调用：
 ```
 gitea doctor recreate-table
 ```
 强烈建议在运行这些命令之前备份您的数据库。
 ### manager
 管理运行中的服务器操作：
 - 命令:
  - `shutdown`: 优雅地关闭运行中的进程
  - `restart`: 优雅地重新启动运行中的进程（对于Windows服务器尚未实现）
  - `flush-queues`: 刷新运行中的进程中的队列
    - 选项:
      - `--timeout value`: 刷新过程的超时时间（默认值: 1m0s）
      - `--non-blocking`: 设置为true，以在返回之前不等待刷新完成
  - `logging`: 调整日志命令
    - 命令:
      - `pause`: 暂停日志记录
        - 注意:
          - 如果日志级别低于此级别，日志级别将被临时提升为INFO。
          - Gitea将在一定程度上缓冲日志，并在超过该点后丢弃日志。
      - `resume`: 恢复日志记录
      - `release-and-reopen`: 使Gitea释放和重新打开用于日志记录的文件和连接（相当于向Gitea发送SIGUSR1信号）。
      - `remove name`: 删除指定的日志记录器
        - 选项:
          - `--group group`, `-g group`: 从中删除子记录器的组（默认为`default`）
      - `add`: 添加日志记录器
        - 命令:
          - `console`: 添加控制台日志记录器
            - 选项:
              - `--group value`, `-g value`: 要添加日志记录器的组 - 默认为"default"
              - `--name value`, `-n value`: 新日志记录器的名称 - 默认为模式
              - `--level value`, `-l value`: 新日志记录器的日志级别
              - `--stacktrace-level value`, `-L value`: 堆栈跟踪日志级别
              - `--flags value`, `-F value`: 日志记录器的标志
              - `--expression value`, `-e value`: 日志记录器的匹配表达式
              - `--prefix value`, `-p value`: 日志记录器的前缀
              - `--color`: 在日志中使用颜色
              - `--stderr`: 将控制台日志输出到stderr - 仅适用于控制台
          - `file`: 添加文件日志记录器
            - 选项:
              - `--group value`, `-g value`: 要添加日志记录器的组 - 默认为"default"
              - `--name value`, `-n value`: 新日志记录器的名称 - 默认为模式
              - `--level value`, `-l value`: 新日志记录器的日志级别
              - `--stacktrace-level value`, `-L value`: 堆栈跟踪日志级别
              - `--flags value`, `-F value`: 日志记录器的标志
              - `--expression value`, `-e value`: 日志记录器的匹配表达式
              - `--prefix value`, `-p value`: 日志记录器的前缀
              - `--color`: 在日志中使用颜色
              - `--filename value`, `-f value`: 日志记录器的文件名
              - `--rotate`, `-r`: 轮转日志
              - `--max-size value`, `-s value`: 在轮转之前的最大大小（以字节为单位）
              - `--daily`, `-d`: 每天轮转日志
              - `--max-days value`, `-D value`: 保留的每日日志的最大数量
              - `--compress`, `-z`: 压缩轮转的日志
              - `--compression-level value`, `-Z value`: 使用的压缩级别
          - `conn`: 添加网络连接日志记录器
            - 选项:
              - `--group value`, `-g value`: 要添加日志记录器的组 - 默认为"default"
              - `--name value`, `-n value`: 新日志记录器的名称 - 默认为模式
              - `--level value`, `-l value`: 新日志记录器的日志级别
              - `--stacktrace-level value`, `-L value`: 堆栈跟踪日志级别
              - `--flags value`, `-F value`: 日志记录器的标志
              - `--expression value`, `-e value`: 日志记录器的匹配表达式
              - `--prefix value`, `-p value`: 日志记录器的前缀
              - `--color`: 在日志中使用颜色
              - `--reconnect-on-message`, `-R`: 对于每个消息重新连接主机
              - `--reconnect`, `-r`: 连接中断时重新连接主机
              - `--protocol value`, `-P value`: 设置要使用的协议：tcp、unix或udp（默认为tcp）
              - `--address value`, `-a value`: 要连接到的主机地址和端口（默认为:7020）
          - `smtp`: 添加SMTP日志记录器
            - 选项:
              - `--group value`, `-g value`: 要添加日志记录器的组 - 默认为"default"
              - `--name value`, `-n value`: 新日志记录器的名称 - 默认为模式
              - `--level value`, `-l value`: 新日志记录器的日志级别
              - `--stacktrace-level value`, `-L value`: 堆栈跟踪日志级别
              - `--flags value`, `-F value`: 日志记录器的标志
              - `--expression value`, `-e value`: 日志记录器的匹配表达式
              - `--prefix value`, `-p value`: 日志记录器的前缀
              - `--color`: 在日志中使用颜色
              - `--username value`, `-u value`: 邮件服务器用户名
              - `--password value`, `-P value`: 邮件服务器密码
              - `--host value`, `-H value`: 邮件服务器主机（默认为: 127.0.0.1:25）
              - `--send-to value`, `-s value`: 要发送到的电子邮件地址
              - `--subject value`, `-S value`: 发送电子邮件的主题标题
  - `processes`: 显示 Gitea 进程和 Goroutine 信息
    - 选项:
      - `--flat`: 以平面表格形式显示进程，而不是树形结构
      - `--no-system`: 不显示系统进程
      - `--stacktraces`: 显示与进程关联的 Goroutine 的堆栈跟踪
      - `--json`: 输出为 JSON 格式
      - `--cancel PID`: 向具有 PID 的进程发送取消命令（仅适用于非系统进程）
 ### dump-repo
 `dump-repo` 从 Git/GitHub/Gitea/GitLab 中转储存储库数据：
 - 选项：
  - `--git_service service`：Git 服务，可以是 `git`、`github`、`gitea`、`gitlab`。如果 `clone_addr` 可以被识别，则可以忽略此选项。
  - `--repo_dir dir`，`-r dir`：存储数据的存储库目录路径。
  - `--clone_addr addr`：将被克隆的 URL，目前可以是 git/github/gitea/gitlab 的 http/https URL。例如：https://github.com/lunny/tango.git
  - `--auth_username lunny`：访问 `clone_addr` 的用户名。
  - `--auth_password <password>`：访问 `clone_addr` 的密码。
  - `--auth_token <token>`：访问 `clone_addr` 的个人令牌。
  - `--owner_name lunny`：如果非空，数据将存储在具有所有者名称的目录中。
  - `--repo_name tango`：如果非空，数据将存储在具有存储库名称的目录中。
  - `--units <units>`：要迁移的项目，一个或多个项目应以逗号分隔。允许的项目有 wiki, issues, labels, releases, release_assets, milestones, pull_requests, comments。如果为空，则表示所有项目。
 ### restore-repo
 `restore-repo` 从磁盘目录中还原存储库数据：
 - 选项：
  - `--repo_dir dir`，`-r dir`：还原数据的存储库目录路径。
  - `--owner_name lunny`：还原目标所有者名称。
  - `--repo_name tango`：还原目标存储库名称。
  - `--units <units>`：要还原的项目，一个或多个项目应以逗号分隔。允许的项目有 wiki, issues, labels, releases, release_assets, milestones, pull_requests, comments。如果为空，则表示所有项目。
 ### actions generate-runner-token
 生成一个供 Runner 使用的新令牌，用于向服务器注册。
 - 选项：
  - `--scope {owner}[/{repo}]`，`-s {owner}[/{repo}]`：限制 Runner 的范围，没有范围表示该 Runner 可用于所有仓库，但你也可以将其限制为特定的仓库或所有者。
 要注册全局 Runner：
 ```
 gitea actions generate-runner-token
 ```
 要注册特定组织的 Runner，例如 `org`：
 ```
 gitea actions generate-runner-token -s org
 ```
 要注册特定仓库的 Runner，例如 `username/test-repo`：
 ```
 gitea actions generate-runner-token -s username/test-repo
 ```
--- a/docs/content/doc/administration/email-setup.zh-cn.md
+++ b/docs/content/doc/administration/email-setup.zh-cn.md
@ -0,0 +1,91 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "Email 设置"
 slug: "email-setup"
 weight: 12
 toc: false
 draft: false
 aliases:
  - /zh-cn/email-setup
 menu:
  sidebar:
    parent: "administration"
    name: "Email 设置"
    weight: 12
    identifier: "email-setup"
 ---
 # Email 设置
 **目录**
 {{< toc >}}
 Gitea 具有邮件功能，用于发送事务性邮件（例如注册确认邮件）。它可以配置为使用 Sendmail（或兼容的 MTA，例如 Postfix 和 msmtp）或直接使用 SMTP 服务器。
 ## 使用 Sendmail
 使用 `sendmail` 命令作为邮件传输代理（mailer）。
 注意：对于在官方Gitea Docker镜像中使用，请使用SMTP版本进行配置（请参考下一节）。
 注意：对于面向互联网的网站，请查阅您的 MTA 文档以了解通过TLS发送邮件的说明。同时设置 SPF、DMARC 和 DKIM DNS 记录，以使发送的邮件被各个电子邮件提供商接受为合法邮件。
 ```ini
 [mailer]
 ENABLED       = true
 FROM          = gitea@mydomain.com
 MAILER_TYPE   = sendmail
 SENDMAIL_PATH = /usr/sbin/sendmail
 SENDMAIL_ARGS = "--" ; 大多数 "sendmail" 程序都接受选项，使用 "--" 将防止电子邮件地址被解释为选项。
 ```
 ## 使用 SMTP
 直接使用 SMTP 服务器作为中继。如果您不想在实例上设置 MTA，但在电子邮件提供商那里有一个帐户，这个选项非常有用。
 ```ini
 [mailer]
 ENABLED        = true
 FROM           = gitea@mydomain.com
 MAILER_TYPE    = smtp
 SMTP_ADDR      = mail.mydomain.com
 SMTP_PORT      = 587
 IS_TLS_ENABLED = true
 USER           = gitea@mydomain.com
 PASSWD         = `password`
 ```
 重启 Gitea 以使配置更改生效。
 要发送测试邮件以验证设置，请转到 Gitea > 站点管理 > 配置 > SMTP 邮件配置。
 有关所有选项的完整列表，请查看[配置速查表](doc/administration/config-cheat-sheet.zh-cn.md)。
 请注意：只有在使用 TLS 或 `HOST=localhost` 加密 SMTP 服务器通信时才支持身份验证。TLS 加密可以通过以下方式进行：
 - 通过端口 587 的 STARTTLS（也称为 Opportunistic TLS）。初始连接是明文的，但如果服务器支持，则可以升级为 TLS。
 - 通过默认端口 465 的 SMTPS 连接。连接到服务器从一开始就使用 TLS。
 - 使用 `IS_TLS_ENABLED=true` 进行强制的 SMTPS 连接。（这两种方式都被称为 Implicit TLS）
 这是由于 Go 内部库对 STRIPTLS 攻击的保护机制。
 请注意，自2018年起，[RFC8314](https://tools.ietf.org/html/rfc8314#section-3) 推荐使用 Implicit TLS。
 ### Gmail
 以下配置应该适用于 Gmail 的 SMTP 服务器：
 ```ini
 [mailer]
 ENABLED        = true
 HOST           = smtp.gmail.com:465 ; 对于 Gitea >= 1.18.0，删除此行
 SMTP_ADDR      = smtp.gmail.com
 SMTP_PORT      = 465
 FROM           = example.user@gmail.com
 USER           = example.user
 PASSWD         = `***`
 MAILER_TYPE    = smtp
 IS_TLS_ENABLED = true
 ```
 请注意，您需要创建并使用一个 [应用密码](https://support.google.com/accounts/answer/185833?hl=en) 并在您的 Google 帐户上启用 2FA。您将无法直接使用您的 Google 帐户密码。
--- a/docs/content/doc/administration/external-renderers.zh-cn.md
+++ b/docs/content/doc/administration/external-renderers.zh-cn.md
@ -0,0 +1,207 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "外部渲染器"
 slug: "external-renderers"
 weight: 60
 toc: false
 draft: false
 aliases:
  - /zh-cn/external-renderers
 menu:
  sidebar:
    parent: "administration"
    name: "外部渲染器"
    weight: 60
    identifier: "external-renderers"
 ---
 # 自定义文件渲染配置
 **目录**
 {{< toc >}}
 Gitea 通过外部二进制文件支持自定义文件渲染（例如 Jupyter notebooks、asciidoc 等），只需要进行以下步骤：
 - 安装外部二进制文件
 - 在您的 `app.ini` 文件中添加一些配置
 - 重新启动 Gitea 实例
 此功能支持整个文件的渲染。如果您想要在 Markdown 中渲染代码块，您需要使用 JavaScript 进行一些操作。请参阅 [自定义 Gitea 配置]({{< relref "doc/administration/customizing-gitea.zh-cn.md" >}}) 页面上的一些示例。
 ## 安装外部二进制文件
 为了通过外部二进制文件进行文件渲染，必须安装它们的关联软件包。
 如果您正在使用 Docker 镜像，则您的 `Dockerfile` 应该包含以下内容：
 ```docker
 FROM gitea/gitea:{{< version >}}
 [...]
 COPY custom/app.ini /data/gitea/conf/app.ini
 [...]
 RUN apk --no-cache add asciidoctor freetype freetype-dev gcc g++ libpng libffi-dev py-pip python3-dev py3-pip py3-pyzmq
 # 安装其他您需要的外部渲染器的软件包
 RUN pip3 install --upgrade pip
 RUN pip3 install -U setuptools
 RUN pip3 install jupyter docutils
 # 在上面添加您需要安装的任何其他 Python 软件包
 ```
 ## `app.ini` 文件配置
 在您的自定义 `app.ini` 文件中为每个外部渲染器添加一个 `[markup.XXXXX]` 部分：
 ```ini
 [markup.asciidoc]
 ENABLED = true
 FILE_EXTENSIONS = .adoc,.asciidoc
 RENDER_COMMAND = "asciidoctor -s -a showtitle --out-file=- -"
 ; 输入不是标准输入而是文件
 IS_INPUT_FILE = false
 [markup.jupyter]
 ENABLED = true
 FILE_EXTENSIONS = .ipynb
 RENDER_COMMAND = "jupyter nbconvert --stdin --stdout --to html --template basic"
 IS_INPUT_FILE = false
 [markup.restructuredtext]
 ENABLED = true
 FILE_EXTENSIONS = .rst
 RENDER_COMMAND = "timeout 30s pandoc +RTS -M512M -RTS -f rst"
 IS_INPUT_FILE = false
 ```
 如果您的外部标记语言依赖于在生成的 HTML 元素上的额外类和属性，您可能需要启用自定义的清理策略。Gitea 使用 [`bluemonday`](https://godoc.org/github.com/microcosm-cc/bluemonday) 包作为我们的 HTML 清理器。下面的示例可以用于支持从 [`pandoc`](https://pandoc.org/) 输出的服务器端 [KaTeX](https://katex.org/) 渲染结果。
 ```ini
 [markup.sanitizer.TeX]
 ; Pandoc 渲染 TeX 段落为带有 "math" 类的 <span> 元素，根据上下文可能还带有 "inline" 或 "display" 类。
 ; - 请注意，这与我们的 Markdown 解析器中内置的数学支持不同，后者使用 <code> 元素。
 ELEMENT = span
 ALLOW_ATTR = class
 REGEXP = ^\s*((math(\s+|$)|inline(\s+|$)|display(\s+|$)))+
 [markup.markdown]
 ENABLED         = true
 FILE_EXTENSIONS = .md,.markdown
 RENDER_COMMAND  = pandoc -f markdown -t html --katex
 ```
 您必须在每个部分中定义 `ELEMENT` 和 `ALLOW_ATTR`。
 要定义多个条目，请添加唯一的字母数字后缀（例如，`[markup.sanitizer.1]` 和 `[markup.sanitizer.something]`）。
 要仅为特定的外部渲染器应用清理规则，它们必须使用渲染器名称，例如 `[markup.sanitizer.asciidoc.rule-1]`、`[markup.sanitizer.<renderer>.rule-1]`。
 **注意**：如果规则在渲染器 ini 部分之前定义，或者名称与渲染器不匹配，它将应用于所有渲染器。
 完成配置更改后，请重新启动 Gitea 以使更改生效。
 **注意**：在 Gitea 1.12 之前，存在一个名为 `markup.sanitiser` 的单个部分，其中的键被重新定义为多个规则，但是，这种配置方法存在重大问题，需要通过多个部分进行配置。
 ### 示例：HTML
 直接渲染 HTML 文件：
 ```ini
 [markup.html]
 ENABLED         = true
 FILE_EXTENSIONS = .html,.htm
 RENDER_COMMAND  = cat
 ; 输入不是标准输入，而是文件
 IS_INPUT_FILE   = true
 [markup.sanitizer.html.1]
 ELEMENT = div
 ALLOW_ATTR = class
 [markup.sanitizer.html.2]
 ELEMENT = a
 ALLOW_ATTR = class
 ```
 请注意：此示例中的配置将允许渲染 HTML 文件，并使用 `cat` 命令将文件内容输出为 HTML。此外，配置中的两个清理规则将允许 `<div>` 和 `<a>` 元素使用 `class` 属性。
 在进行配置更改后，请重新启动 Gitea 以使更改生效。
 ### 示例：Office DOCX
 使用 [`pandoc`](https://pandoc.org/) 显示 Office DOCX 文件：
 ```ini
 [markup.docx]
 ENABLED = true
 FILE_EXTENSIONS = .docx
 RENDER_COMMAND = "pandoc --from docx --to html --self-contained --template /path/to/basic.html"
 [markup.sanitizer.docx.img]
 ALLOW_DATA_URI_IMAGES = true
 ```
 在此示例中，配置将允许显示 Office DOCX 文件，并使用 `pandoc` 命令将文件转换为 HTML 格式。同时，清理规则中的 `ALLOW_DATA_URI_IMAGES` 设置为 `true`，允许使用 Data URI 格式的图片。
 模板文件的内容如下：
 ```
 $body$
 ```
 ### 示例：Jupyter Notebook
 使用 [`nbconvert`](https://github.com/jupyter/nbconvert) 显示 Jupyter Notebook 文件：
 ```ini
 [markup.jupyter]
 ENABLED = true
 FILE_EXTENSIONS = .ipynb
 RENDER_COMMAND = "jupyter-nbconvert --stdin --stdout --to html --template basic"
 [markup.sanitizer.jupyter.img]
 ALLOW_DATA_URI_IMAGES = true
 ```
 在此示例中，配置将允许显示 Jupyter Notebook 文件，并使用 `nbconvert` 命令将文件转换为 HTML 格式。同样，清理规则中的 `ALLOW_DATA_URI_IMAGES` 设置为 `true`，允许使用 Data URI 格式的图片。
 在进行配置更改后，请重新启动 Gitea 以使更改生效。
 ## 自定义 CSS
 在 `.ini` 文件中，可以使用 `[markup.XXXXX]` 的格式指定外部渲染器，并且由外部渲染器生成的 HTML 将被包装在一个带有 `markup` 和 `XXXXX` 类的 `<div>` 中。`markup` 类提供了预定义的样式（如果 `XXXXX` 是 `markdown`，则使用 `markdown` 类）。否则，您可以使用这些类来针对渲染的 HTML 内容进行定制样式。
 因此，您可以编写一些 CSS 样式：
 ```css
 .markup.XXXXX html {
  font-size: 100%;
  overflow-y: scroll;
  -webkit-text-size-adjust: 100%;
  -ms-text-size-adjust: 100%;
 }
 .markup.XXXXX body {
  color: #444;
  font-family: Georgia, Palatino, 'Palatino Linotype', Times, 'Times New Roman', serif;
  font-size: 12px;
  line-height: 1.7;
  padding: 1em;
  margin: auto;
  max-width: 42em;
  background: #fefefe;
 }
 .markup.XXXXX p {
  color: orangered;
 }
 ```
 将您的样式表添加到自定义目录中，例如 `custom/public/css/my-style-XXXXX.css`，并使用自定义的头文件 `custom/templates/custom/header.tmpl` 进行导入：
 ```html
 <link rel="stylesheet" href="{{AppSubUrl}}/assets/css/my-style-XXXXX.css" />
 ```
 通过以上步骤，您可以将自定义的 CSS 样式应用到特定的外部渲染器，使其具有所需的样式效果。
--- a/docs/content/doc/administration/git-lfs-support.zh-cn.md
+++ b/docs/content/doc/administration/git-lfs-support.zh-cn.md
@ -0,0 +1,32 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "Git LFS 设置"
 slug: "git-lfs-setup"
 weight: 12
 toc: false
 draft: false
 aliases:
  - /zh-cn/git-lfs-setup
 menu:
  sidebar:
    parent: "administration"
    name: "Git LFS 设置"
    weight: 12
    identifier: "git-lfs-setup"
 ---
 # 配置 Git 大文件存储（Large File Storage，LFS）
 要使用 Gitea 内置的 LFS 支持，您需要更新 `app.ini` 文件：
 ```ini
 [server]
 ; 启用 git-lfs 支持。true 或 false，默认为 false。
 LFS_START_SERVER = true
 [lfs]
 ; 存放 LFS 文件的路径，默认为 data/lfs。
 PATH = /home/gitea/data/lfs
 ```
 **注意**：LFS 服务器支持需要服务器上安装 Git v2.1.2 以上版本。
--- a/docs/content/doc/administration/logging-config.zh-cn.md
+++ b/docs/content/doc/administration/logging-config.zh-cn.md
@ -0,0 +1,272 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "日志配置"
 slug: "logging-config"
 weight: 40
 toc: false
 draft: false
 aliases:
  - /zh-cn/logging-configuration
 menu:
  sidebar:
    parent: "administration"
    name: "日志配置"
    weight: 40
    identifier: "logging-config"
 ---
 # 日志配置
 Gitea 的日志配置主要由以下三种类型的组件组成：
 - `[log]` 部分用于一般配置
 - `[log.<mode-name>]` 部分用于配置不同的日志输出方式，也称为 "writer mode"，模式名称同时也作为 "writer name"
 - `[log]` 部分还可以包含遵循 `logger.<logger-name>.<CONFIG-KEY>` 模式的子日志记录器的配置
 默认情况下，已经有一个完全功能的日志输出，因此不需要重新定义。
 **目录**
 {{< toc >}}
 ## `[log]` 部分
 在 Gitea 中，日志设施的配置在 `[log]` 部分及其子部分。
 在顶层的 `[log]` 部分，可以放置以下配置项：
 - `ROOT_PATH`：（默认值：**%(GITEA_WORK_DIR)/log**）：日志文件的基本路径。
 - `MODE`：（默认值：**console**）：要用于默认日志记录器的日志输出列表。
 - `LEVEL`：（默认值：**Info**）：要持久化的最严重的日志事件，不区分大小写。可能的值为：`Trace`、`Debug`、`Info`、`Warn`、`Error`、`Fatal`。
 - `STACKTRACE_LEVEL`：（默认值：**None**）：对于此类及更严重的事件，将在记录时打印堆栈跟踪。
 它还可以包含以下子日志记录器：
 - `logger.router.MODE`：（默认值：**,**）：用于路由器日志记录器的日志输出列表。
 - `logger.access.MODE`：（默认值：**\<empty\>**）：用于访问日志记录器的日志输出列表。默认情况下，访问日志记录器被禁用。
 - `logger.xorm.MODE`：（默认值：**,**）：用于 XORM 日志记录器的日志输出列表。
 将子日志记录器的模式设置为逗号（`,`）表示使用默认的全局 `MODE`。
 ## 快速示例
 ### 默认（空）配置
 空配置等同于默认配置：
 ```ini
 [log]
 ROOT_PATH = %(GITEA_WORK_DIR)/log
 MODE = console
 LEVEL = Info
 STACKTRACE_LEVEL = None
 logger.router.MODE = ,
 logger.xorm.MODE = ,
 logger.access.MODE =
 ; 这是“控制台”模式的配置选项（由上面的 MODE=console 使用）
 [log.console]
 MODE = console
 FLAGS = stdflags
 PREFIX =
 COLORIZE = true
 ```
 这等同于将所有日志发送到控制台，并将默认的 Golang 日志也发送到控制台日志中。
 这只是一个示例，默认情况下不需要将其写入配置文件中。
 ### 禁用路由日志并将一些访问日志记录到文件中
 禁用路由日志，将访问日志（>=Warn）记录到 `access.log` 中：
 ```ini
 [log]
 logger.router.MODE =
 logger.access.MODE = access-file
 [log.access-file]
 MODE = file
 LEVEL = Warn
 FILE_NAME = access.log
 ```
 ### 为不同的模式设置不同的日志级别
 将默认日志（>=Warn）记录到 `gitea.log` 中，将错误日志记录到 `file-error.log` 中：
 ```ini
 [log]
 LEVEL = Warn
 MODE = file, file-error
 ; 默认情况下，"file" 模式会将日志记录到 %(log.ROOT_PATH)/gitea.log，因此我们不需要设置它
 ; [log.file]
 [log.file-error]
 LEVEL = Error
 FILE_NAME = file-error.log
 ```
 ## 日志输出（模式和写入器）
 Gitea 提供以下日志写入器：
 - `console` - 输出日志到 `stdout`（或 `stderr`，如果已在配置中设置）
 - `file` - 输出日志到文件
 - `conn` - 输出日志到套接字（网络或 Unix 套接字）
 ### 公共配置
 某些配置适用于所有日志输出模式：
 - `MODE` 是日志输出写入器的模式。它将默认为 ini 部分的模式名称。因此，`[log.console]` 将默认为 `MODE = console`。
 - `LEVEL` 是此输出将记录的最低日志级别。
 - `STACKTRACE_LEVEL` 是此输出将打印堆栈跟踪的最低日志级别。
 - `COLORIZE` 对于 `console`，默认为 `true`，否则默认为 `false`。
 #### `EXPRESSION`
 `EXPRESSION` 表示日志事件必须匹配才能被输出写入器记录的正则表达式。
 日志消息（去除颜色）或 `longfilename:linenumber:functionname` 必须匹配其中之一。
 注意：整个消息或字符串不需要完全匹配。
 请注意，此表达式将在写入器的 goroutine 中运行，而不是在日志事件的 goroutine 中运行。
 #### `FLAGS`
 `FLAGS` 表示在每条消息之前打印的前置日志上下文信息。
 它是一个逗号分隔的字符串集。值的顺序无关紧要。
 默认值为 `stdflags`（= `date,time,medfile,shortfuncname,levelinitial`）。
 可能的值为：
 - `none` 或 `,` - 无标志。
 - `date` - 当地时区的日期：`2009/01/23`。
 - `time` - 当地时区的时间：`01:23:23`。
 - `microseconds` - 微秒精度：`01:23:23.123123`。假定有时间。
 - `longfile` - 完整的文件名和行号：`/a/b/c/d.go:23`。
 - `shortfile` - 文件名的最后一个部分和行号：`d.go:23`。
 - `funcname` - 调用者的函数名：`runtime.Caller()`。
 - `shortfuncname` - 函数名的最后一部分。覆盖 `funcname`。
 - `utc` - 如果设置了日期或时间，则使用 UTC 而不是本地时区。
 - `levelinitial` - 提供的级别的初始字符，放在方括号内，例如 `[I]` 表示 info。
 - `level` - 在方括号内的级别，例如 `[INFO]`。
 - `gopid` - 上下文的 Goroutine-PID。
 - `medfile` - 文件名的最后 20 个字符 - 相当于 `shortfile,longfile`。
 - `stdflags` - 相当于 `date,time,medfile,shortfuncname,levelinitial`。
 ### Console 模式
 在此模式下，日志记录器将将日志消息转发到 Gitea 进程附加的 stdout 和 stderr 流。
 对于 console 模式的日志记录器，如果不在 Windows 上，或者 Windows 终端可以设置为 ANSI 模式，或者是 cygwin 或 Msys 管道，则 `COLORIZE` 默认为 `true`。
 设置：
 - `STDERR`：**false**：日志记录器是否应将日志打印到 `stderr` 而不是 `stdout`。
 ### File 模式
 在此模式下，日志记录器将将日志消息保存到文件中。
 设置：
 - `FILE_NAME`：要将日志事件写入的文件，相对于 `ROOT_PATH`，默认为 `%(ROOT_PATH)/gitea.log`。异常情况：访问日志默认为 `%(ROOT_PATH)/access.log`。
 - `MAX_SIZE_SHIFT`：**28**：单个文件的最大大小位移。28 表示 256Mb。详细信息见下文。
 - `LOG_ROTATE` **true**：是否轮转日志文件。
 - `DAILY_ROTATE`：**true**：是否每天旋转日志。
 - `MAX_DAYS`：**7**：在此天数之后删除旋转的日志文件。
 - `COMPRESS`：**true**：默认情况下是否使用 gzip 压缩旧的日志文件。
 - `COMPRESSION_LEVEL`：**-1**：压缩级别。详细信息见下文。
 `MAX_SIZE_SHIFT` 通过将给定次数左移 1 (`1 << x`) 来定义文件的最大大小。
 在 v1.17.3 版本时的确切行为可以在[这里](https://github.com/go-gitea/gitea/blob/v1.17.3/modules/setting/log.go#L185)中查看。
 `COMPRESSION_LEVEL` 的有用值范围从 1 到（包括）9，其中较高的数字表示更好的压缩。
 请注意，更好的压缩可能会带来更高的资源使用。
 必须在前面加上 `-` 符号。
 ### Conn 模式
 在此模式下，日志记录器将通过网络套接字发送日志消息。
 设置：
 - `ADDR`：**:7020**：设置要连接的地址。
 - `PROTOCOL`：**tcp**：设置协议，可以是 "tcp"、"unix" 或 "udp"。
 - `RECONNECT`：**false**：在连接丢失时尝试重新连接。
 - `RECONNECT_ON_MSG`：**false**：为每条消息重新连接主机。
 ### "Router" 日志记录器
 当 Gitea 的路由处理程序工作时，Router 日志记录器记录以下消息类型：
 - `started` 消息将以 TRACE 级别记录
 - `polling`/`completed` 路由将以 INFO 级别记录。异常情况："/assets" 静态资源请求也会以 TRACE 级别记录。
 - `slow` 路由将以 WARN 级别记录
 - `failed` 路由将以 WARN 级别记录
 ### "XORM" 日志记录器
 为了使 XORM 输出 SQL 日志，还应将 `[database]` 部分中的 `LOG_SQL` 设置为 `true`。
 ### "Access" 日志记录器
 "Access" 日志记录器是自 Gitea 1.9 版本以来的新日志记录器。它提供了符合 NCSA Common Log 标准的日志格式。虽然它具有高度可配置性，但在更改其模板时应谨慎。此日志记录器的主要好处是，Gitea 现在可以使用标准日志格式记录访问日志，因此可以使用标准工具进行分析。
 您可以通过使用 `logger.access.MODE = ...` 来启用此日志记录器。
 如果需要，可以通过更改 `ACCESS_LOG_TEMPLATE` 的值来更改 "Access" 日志记录器的格式。
 请注意，访问日志记录器将以 `INFO` 级别记录，将此日志记录器的 `LEVEL` 设置为 `WARN` 或更高级别将导致不记录访问日志。
 #### ACCESS_LOG_TEMPLATE
 此值表示一个 Go 模板。其默认值为
 ```tmpl
 {{.Ctx.RemoteHost}} - {{.Identity}} {{.Start.Format "[02/Jan/2006:15:04:05 -0700]" }} "{{.Ctx.Req.Method}} {{.Ctx.Req.URL.RequestURI}} {{.Ctx.Req.Proto}}" {{.ResponseWriter.Status}} {{.ResponseWriter.Size}} "{{.Ctx.Req.Referer}}" "{{.Ctx.Req.UserAgent}}"`
 ```
 模板接收以下选项：
 - `Ctx` 是 `context.Context`
 - `Identity` 是 `SignedUserName`，如果用户未登录，则为 "-"
 - `Start` 是请求的开始时间
 - `ResponseWriter` 是 `http.ResponseWriter`
 更改此模板时必须小心，因为它在标准的 panic 恢复陷阱之外运行。此模板应该尽可能简单，因为它会为每个请求运行一次。
 ## 释放和重新打开、暂停和恢复日志记录
 如果您在 Unix 上运行，您可能希望释放和重新打开日志以使用 `logrotate` 或其他工具。
 可以通过向运行中的进程发送 `SIGUSR1` 信号或运行 `gitea manager logging release-and-reopen` 命令来强制 Gitea 释放并重新打开其日志文件和连接。
 或者，您可能希望暂停和恢复日志记录 - 可以通过使用 `gitea manager logging pause` 和 `gitea manager logging resume` 命令来实现。请注意，当日志记录暂停时，低于 INFO 级别的日志事件将不会存储，并且只会存储有限数量的事件。在暂停时，日志记录可能会阻塞，尽管是暂时性的，但会大大减慢 Gitea 的运行速度，因此建议仅暂停很短的时间。
 ### 在 Gitea 运行时添加和删除日志记录
 可以使用 `gitea manager logging add` 和 `remove` 子命令在 Gitea 运行时添加和删除日志记录。
 此功能只能调整正在运行的日志系统，不能用于启动未初始化的访问或路由日志记录器。如果您希望启动这些系统，建议调整 app.ini 并（优雅地）重新启动 Gitea 服务。
 这些命令的主要目的是在运行中的系统上轻松添加临时日志记录器，以便调查问题，因为重新启动可能会导致问题消失。
 ## 使用 `logrotate` 而不是内置的日志轮转
 Gitea 包含内置的日志轮转功能，对于大多数部署来说应该已经足够了。但是，如果您想使用 `logrotate` 工具：
 - 在 `app.ini` 中将 `LOG_ROTATE` 设置为 `false`，禁用内置的日志轮转。
 - 安装 `logrotate`。
 - 根据部署要求配置 `logrotate`，有关配置语法细节，请参阅 `man 8 logrotate`。
  在 `postrotate/endscript` 块中通过 `kill -USR1` 或 `kill -10` 向 `gitea` 进程本身发送 `USR1` 信号，
  或者运行 `gitea manager logging release-and-reopen`（使用适当的环境设置）。
  确保配置适用于由 Gitea 日志记录器生成的所有文件，如上述部分所述。
 - 始终使用 `logrotate /etc/logrotate.conf --debug` 来测试您的配置。
 - 如果您正在使用 Docker 并从容器外部运行，您可以使用
  `docker exec -u $OS_USER $CONTAINER_NAME sh -c 'gitea manager logging release-and-reopen'`
  或 `docker exec $CONTAINER_NAME sh -c '/bin/s6-svc -1 /etc/s6/gitea/'`，或直接向 Gitea 进程本身发送 `USR1` 信号。
 下一个 `logrotate` 作业将包括您的配置，因此不需要重新启动。
 您还可以立即使用 `logrotate /etc/logrotate.conf --force` 重新加载 `logrotate`。
--- a/docs/content/doc/administration/mail-templates.zh-cn.md
+++ b/docs/content/doc/administration/mail-templates.zh-cn.md
@ -0,0 +1,265 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "邮件模板"
 slug: "mail-templates"
 weight: 45
 toc: false
 draft: false
 aliases:
  - /zh-cn/mail-templates
 menu:
  sidebar:
    parent: "administration"
    name: "邮件模板"
    weight: 45
    identifier: "mail-templates"
 ---
 # 邮件模板
 **目录**
 {{< toc >}}
 为了定制特定操作的电子邮件主题和内容，可以使用模板来自定义 Gitea。这些功能的模板位于 [`custom` 目录](https://docs.gitea.io/en-us/customizing-gitea/) 下。
 如果没有自定义的替代方案，Gitea 将使用内部模板作为默认模板。
 自定义模板在 Gitea 启动时加载。对它们的更改在 Gitea 重新启动之前不会被识别。
 ## 支持模板的邮件通知
 目前，以下通知事件使用模板：
 | 操作名称   | 用途                                                                                    |
 | ----------- | ------------------------------------------------------------------------------------------------------------ |
 | `new`       | 创建了新的工单或合并请求。                                                                    |
 | `comment`   | 在现有工单或合并请求中创建了新的评论。                                                          |
 | `close`     | 关闭了工单或合并请求。                                                                         |
 | `reopen`    | 重新打开了工单或合并请求。                                                                       |
 | `review`    | 在合并请求中进行审查的首要评论。                                                               |
 | `approve`   | 对合并请求进行批准的首要评论。                                                                 |
 | `reject`    | 对合并请求提出更改请求的审查的首要评论。                                                       |
 | `code`      | 关于合并请求的代码的单个评论。                                                                 |
 | `assigned`  | 用户被分配到工单或合并请求。                                                                    |
 | `default`   | 未包括在上述类别中的任何操作，或者当对应类别的模板不存在时使用的模板。                              |
 特定消息类型的模板路径为：
 ```sh
 custom/templates/mail/{操作类型}/{操作名称}.tmpl
 ```
 其中 `{操作类型}` 是 `issue` 或 `pull`（针对合并请求），`{操作名称}` 是上述列出的操作名称之一。
 例如，有关合并请求中的评论的电子邮件的特定模板是：
 ```sh
 custom/templates/mail/pull/comment.tmpl
 ```
 然而，并不需要为每个操作类型/名称组合创建模板。
 使用回退系统来选择适当的模板。在此列表中，将使用 _第一个存在的_ 模板：
 - 所需**操作类型**和**操作名称**的特定模板。
 - 操作类型为 `issue` 和所需**操作名称**的模板。
 - 所需**操作类型**和操作名称为 `default` 的模板。
 - 操作类型为` issue` 和操作名称为 `default` 的模板。
 唯一必需的模板是操作类型为 `issue` 操作名称为 `default` 的模板，除非用户在 `custom` 目录中覆盖了它。
 ## 模板语法
 邮件模板是 UTF-8 编码的文本文件，需要遵循以下格式之一：
 ```
 用于主题行的文本和宏
 ------------
 用于邮件正文的文本和宏
 ```
 或者
 ```
 用于邮件正文的文本和宏
 ```
 指定 _主题_ 部分是可选的（因此也是虚线分隔符）。在使用时，_主题_ 和 _邮件正文_ 模板之间的分隔符需要至少三个虚线；分隔符行中不允许使用其他字符。
 _主题_ 和 _邮件正文_ 由 [Golang的模板引擎](https://golang.org/pkg/text/template/) 解析，并提供了为每个通知组装的 _元数据上下文_。上下文包含以下元素：
 | 名称                 | 类型               | 可用性            | 用途                                                                                                                                                                                                                                             |
 | -------------------- | ------------------ | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `.FallbackSubject`   | string             | 始终可用        | 默认主题行。参见下文。                                                                                                                                                                                                                            |
 | `.Subject`           | string             | 仅在正文中可用  | 解析后的 _主题_。                                                                                                                                                                                                                                 |
 | `.Body`              | string             | 始终可用        | 工单、合并请求或评论的消息，从 Markdown 解析为 HTML 并进行了清理。请勿与 _邮件正文_ 混淆。                                                                                                                                                                 |
 | `.Link`              | string             | 始终可用        | 源工单、合并请求或评论的地址。                                                                                                                                                                                                                    |
 | `.Issue`             | models.Issue       | 始终可用        | 产生通知的工单（或合并请求）。要获取特定于合并请求的数据（例如 `HasMerged`），可以使用 `.Issue.PullRequest`，但需要注意，如果工单 _不是_ 合并请求，则该字段将为 `nil`。                                                                       |
 | `.Comment`           | models.Comment     | 如果适用        | 如果通知是针对添加到工单或合并请求的评论，则其中包含有关评论的信息。                                                                                                                                                                             |
 | `.IsPull`            | bool               | 始终可用        | 如果邮件通知与合并请求关联（即 `.Issue.PullRequest` 不为 `nil` ），则为 `true`。                                                                                                                                                                       |
 | `.Repo`              | string         | 始终可用        | 仓库的名称，包括所有者名称（例如 `mike/stuff`）                                                                                                                                                                                                    |
 | `.User`              | models.User        | 始终可用        | 事件来源仓库的所有者。要获取用户名（例如 `mike`），可以使用 `.User.Name`。                                                                                                                                                                           |
 | `.Doer`              | models.User        | 始终可用        | 执行触发通知事件的操作的用户。要获取用户名（例如 `rhonda`），可以使用 `.Doer.Name`。                                                                                                                                                                |
 | `.IsMention`         | bool               | 始终可用        | 如果此通知仅是因为在评论中提到了用户而生成的，并且收件人未订阅源，则为 `true`。如果收件人已订阅工单或仓库，则为 `false`。                                                                                                                            |
 | `.SubjectPrefix`     | string             | 始终可用        | 如果通知是关于除工单或合并请求创建之外的其他内容，则为 `Re：`；否则为空字符串。                                                                                                                                                                      |
 | `.ActionType`        | string             | 始终可用        | `"issue"` 或 `"pull"`。它将与实际的 _操作类型_ 对应，与选择的模板无关。                                                                                                                                                                                 |
 | `.ActionName`        | string             | 始终可用        | 它将是上述操作类型之一（`new` ，`comment` 等），并与选择的模板对应。                                                                                                                                                                                 |
 | `.ReviewComments`    | []models.Comment   | 始终可用        | 审查中的代码评论列表。评论文本将在 `.RenderedContent` 中，引用的代码将在 `.Patch` 中。                                                                                                                                                                |
 所有名称区分大小写。
 ### 模板中的主题部分
 用于邮件主题的模板引擎是 Golang 的 [`text/template`](https://golang.org/pkg/text/template/)。
 有关语法的详细信息，请参阅链接的文档。
 主题构建的步骤如下：
 - 根据通知类型和可用的模板选择一个模板。
 - 解析并解析模板（例如，将 `{{.Issue.Index}}` 转换为工单或合并请求的编号）。
 - 将所有空格字符（例如 `TAB`，`LF` 等）转换为普通空格。
 - 删除所有前导、尾随和多余的空格。
 - 将字符串截断为前 256 个字母（字符）。
 如果最终结果为空字符串，**或者**没有可用的主题模板（即所选模板不包含主题部分），将使用Gitea的**内部默认值**。
 内部默认（回退）主题相当于：
 ```
 {{.SubjectPrefix}}[{{.Repo}}] {{.Issue.Title}} (#{{.Issue.Index}})
 ```
 例如：`Re: [mike/stuff] New color palette (#38)`
 即使存在有效的主题模板，Gitea的默认主题也可以在模板的元数据中作为 `.FallbackSubject` 找到。
 ### 模板中的邮件正文部分
 用于邮件正文的模板引擎是 Golang 的 [`html/template`](https://golang.org/pkg/html/template/)。
 有关语法的详细信息，请参阅链接的文档。
 邮件正文在邮件主题之后进行解析，因此还有一个额外的 _元数据_ 字段，即在考虑所有情况之后实际呈现的主题。
 期望的结果是 HTML（包括结构元素，如`<html>`，`<body>`等）。可以通过 `<style>` 块、`class` 和 `style` 属性进行样式设置。但是，`html/template` 会进行一些 [自动转义](https://golang.org/pkg/html/template/#hdr-Contexts)，需要考虑这一点。
 不支持附件（例如图像或外部样式表）。但是，也可以引用其他模板，例如以集中方式提供 `<style>` 元素的内容。外部模板必须放置在 `custom/mail` 下，并相对于该目录引用。例如，可以使用 `{{template styles/base}}` 包含 `custom/mail/styles/base.tmpl`。
 邮件以 `Content-Type: multipart/alternative` 发送，因此正文以 HTML 和文本格式发送。通过剥离 HTML 标记来获取文本版本。
 ## 故障排除
 邮件的呈现方式直接取决于邮件应用程序的功能。许多邮件客户端甚至不支持 HTML，因此显示生成邮件中包含的文本版本。
 如果模板无法呈现，则只有在发送邮件时才会注意到。
 如果主题模板失败，将使用默认主题，如果从 _邮件正文_ 中成功呈现了任何内容，则将使用该内容，忽略其他内容。
 如果遇到问题，请检查 [Gitea的日志](https://docs.gitea.io/en-us/logging-configuration/) 以获取错误消息。
 ## 示例
 `custom/templates/mail/issue/default.tmpl`:
 ```html
 [{{.Repo}}] @{{.Doer.Name}}
 {{if eq .ActionName "new"}}
    创建了
 {{else if eq .ActionName "comment"}}
    评论了
 {{else if eq .ActionName "close"}}
    关闭了
 {{else if eq .ActionName "reopen"}}
    重新打开了
 {{else}}
    更新了
 {{end}}
 {{if eq .ActionType "issue"}}
    工单
 {{else}}
    合并请求
 {{end}}
 #{{.Issue.Index}}: {{.Issue.Title}}
 ------------
 <!DOCTYPE html>
 <html>
 <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>{{.Subject}}</title>
 </head>
 <body>
    {{if .IsMention}}
    <p>
        您收到此邮件是因为 @{{.Doer.Name}} 提到了您。
    </p>
    {{end}}
    <p>
        <p>
        <a href="{{AppUrl}}/{{.Doer.LowerName}}">@{{.Doer.Name}}</a>
        {{if not (eq .Doer.FullName "")}}
            ({{.Doer.FullName}})
        {{end}}
        {{if eq .ActionName "new"}}
            创建了
        {{else if eq .ActionName "close"}}
            关闭了
        {{else if eq .ActionName "reopen"}}
            重新打开了
        {{else}}
            更新了
        {{end}}
        <a href="{{.Link}}">{{.Repo}}#{{.Issue.Index}}</a>。
        </p>
        {{if not (eq .Body "")}}
            <h3>消息内容：</h3>
            <hr>
            {{.Body | Str2html}}
        {{end}}
    </p>
    <hr>
    <p>
        <a href="{{.Link}}">在 Gitea 上查看</a>。
    </p>
 </body>
 </html>
 ```
 该模板将生成以下内容：
 ### 主题
 > [mike/stuff] @rhonda 在合并请求 #38 上进行了评论：New color palette
 ### 邮件正文
 > [@rhonda](#)（Rhonda Myers）更新了 [mike/stuff#38](#)。
 >
 > #### 消息内容：
 >
 > \_********************************\_********************************
 >
 > Mike, I think we should tone down the blues a little.
 >
 > \_********************************\_********************************
 >
 > [在 Gitea 上查看](#)。
 ## 高级用法
 模板系统包含一些函数，可用于进一步处理和格式化消息。以下是其中一些函数的列表：
 | 函数名            | 参数        | 可用于       | 用法                                                                              |
 | ----------------- | ----------- | ------------ | --------------------------------------------------------------------------------- |
 | `AppUrl`          | -           | 任何地方     | Gitea 的 URL                                                                     |
 | `AppName`         | -           | 任何地方     | 从 `app.ini` 中设置，通常为 "Gitea"                                               |
 | `AppDomain`       | -           | 任何地方     | Gitea 的主机名                                                                   |
 | `EllipsisString`  | string, int | 任何地方     | 将字符串截断为指定长度；根据需要添加省略号                                        |
 | `Str2html`        | string      | 仅正文部分   | 通过删除其中的 HTML 标签对文本进行清理                                              |
 | `Safe`            | string      | 仅正文部分   | 将输入作为 HTML 处理；可用于 `.ReviewComments.RenderedContent` 等字段               |
 这些都是 _函数_，而不是元数据，因此必须按以下方式使用：
 ```html
 像这样使用：         {{Str2html "Escape<my>text"}}
 或者这样使用：       {{"Escape<my>text" | Str2html}}
 或者这样使用：       {{AppUrl}}
 但不要像这样使用：   {{.AppUrl}}
 ```
--- a/docs/content/doc/administration/repo-indexer.zh-cn.md
+++ b/docs/content/doc/administration/repo-indexer.zh-cn.md
@ -0,0 +1,63 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "仓库索引器"
 slug: "repo-indexer"
 weight: 45
 toc: false
 draft: false
 aliases:
  - /zh-cn/repo-indexer
 menu:
  sidebar:
    parent: "administration"
    name: "仓库索引器"
    weight: 45
    identifier: "repo-indexer"
 ---
 # 仓库索引器
 **目录**
 {{< toc >}}
 ## 设置仓库索引器
 通过在您的 [`app.ini`](https://docs.gitea.io/en-us/config-cheat-sheet/) 中启用此功能，Gitea 可以通过仓库的文件进行搜索：
 ```ini
 [indexer]
 ; ...
 REPO_INDEXER_ENABLED = true
 REPO_INDEXER_PATH = indexers/repos.bleve
 MAX_FILE_SIZE = 1048576
 REPO_INDEXER_INCLUDE =
 REPO_INDEXER_EXCLUDE = resources/bin/**
 ```
 请记住，索引内容可能会消耗大量系统资源，特别是在首次创建索引或全局更新索引时（例如升级 Gitea 之后）。
 ### 按大小选择要索引的文件
 `MAX_FILE_SIZE` 选项将使索引器跳过所有大于指定值的文件。
 ### 按路径选择要索引的文件
 Gitea使用 [`gobwas/glob` 库](https://github.com/gobwas/glob) 中的 glob 模式匹配来选择要包含在索引中的文件。
 限制文件列表可以防止索引被派生或无关的文件（例如 lss、sym、map 等）污染，从而使搜索结果更相关。这还有助于减小索引的大小。
 `REPO_INDEXER_EXCLUDE_VENDORED`（默认值为 true）将排除供应商文件不包含在索引中。
 `REPO_INDEXER_INCLUDE`（默认值为空）是一个逗号分隔的 glob 模式列表，用于在索引中**包含**的文件。空列表表示“_包含所有文件_”。
 `REPO_INDEXER_EXCLUDE`（默认值为空）是一个逗号分隔的 glob 模式列表，用于从索引中**排除**的文件。与该列表匹配的文件将不会被索引。`REPO_INDEXER_EXCLUDE` 优先于 `REPO_INDEXER_INCLUDE`。
 模式匹配工作方式如下：
 - 要匹配所有带有 `.txt` 扩展名的文件，无论在哪个目录中，请使用 `**.txt`。
 - 要匹配仅在仓库的根级别中具有 `.txt` 扩展名的所有文件，请使用 `*.txt`。
 - 要匹配 `resources/bin` 目录及其子目录中的所有文件，请使用 `resources/bin/**`。
 - 要匹配位于 `resources/bin` 目录下的所有文件，请使用 `resources/bin/*`。
 - 要匹配所有名为 `Makefile` 的文件，请使用 `**Makefile`。
 - 匹配目录没有效果；模式 `resources/bin` 不会包含/排除该目录中的文件；`resources/bin/**` 会。
 - 所有文件和模式都规范化为小写，因此 `**Makefile`、`**makefile` 和 `**MAKEFILE` 是等效的。
--- a/docs/content/doc/administration/search-engines-indexation.zh-cn.md
+++ b/docs/content/doc/administration/search-engines-indexation.zh-cn.md
@ -0,0 +1,39 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "搜索引擎索引"
 slug: "search-engines-indexation"
 weight: 60
 toc: false
 draft: false
 aliases:
  - /zh-cn/search-engines-indexation
 menu:
  sidebar:
    parent: "administration"
    name: "搜索引擎索引"
    weight: 60
    identifier: "search-engines-indexation"
 ---
 # Gitea 安装的搜索引擎索引
 默认情况下，您的 Gitea 安装将被搜索引擎索引。
 如果您不希望您的仓库对搜索引擎可见，请进一步阅读。
 ## 使用 robots.txt 阻止搜索引擎索引
 为了使 Gitea 为顶级安装提供自定义的`robots.txt`（默认为空的 404），请在[`custom`文件夹或`CustomPath`]（{{< relref "doc/administration/customizing-gitea.zh-cn.md" >}}）中创建一个名为 `robots.txt` 的文件。
 有关如何配置 `robots.txt` 的示例，请参考 [https://moz.com/learn/seo/robotstxt](https://moz.com/learn/seo/robotstxt)。
 ```txt
 User-agent: *
 Disallow: /
 ```
 如果您将Gitea安装在子目录中，则需要在顶级目录中创建或编辑 `robots.txt`。
 ```txt
 User-agent: *
 Disallow: /gitea/
 ```
--- a/docs/content/doc/administration/signing.zh-cn.md
+++ b/docs/content/doc/administration/signing.zh-cn.md
@ -0,0 +1,146 @@
 ---
 date: "2023-05-23T09:00:00+08:00"
 title: "GPG 提交签名"
 slug: "signing"
 weight: 50
 toc: false
 draft: false
 aliases:
  - /zh-cn/signing
 menu:
  sidebar:
    parent: "administration"
    name: "GPG 提交签名"
    weight: 50
    identifier: "signing"
 ---
 # GPG 提交签名
 **目录**
 {{< toc >}}
 Gitea 将通过检查提交是否由 Gitea 数据库中的密钥签名，或者提交是否与 Git 的默认密钥匹配，来验证提供的树中的 GPG 提交签名。
 密钥不会被检查以确定它们是否已过期或撤销。密钥也不会与密钥服务器进行检查。
 如果找不到用于验证提交的密钥，提交将被标记为灰色的未锁定图标。如果提交被标记为红色的未锁定图标，则表示它使用带有 ID 的密钥签名。
 请注意：提交的签署者不必是提交的作者或提交者。
 此功能要求 Git >= 1.7.9，但要实现全部功能，需要 Git >= 2.0.0。
 ## 自动签名
 有许多地方 Gitea 会生成提交：
 - 仓库初始化
 - Wiki 更改
 - 使用编辑器或 API 进行的 CRUD 操作
 - 从合并请求进行合并
 根据配置和服务器信任，您可能希望 Gitea 对这些提交进行签名。
 ## 安装和生成 Gitea 的 GPG 密钥
 如何安装签名密钥由服务器管理员决定。Gitea 目前使用服务器的 `git` 命令生成所有提交，因此将使用服务器的 `gpg` 进行签名（如果配置了）。管理员应该审查 GPG 的最佳实践 - 特别是可能建议仅安装签名的子密钥，而不是主签名和认证的密钥。
 ## 通用配置
 Gitea 的签名配置可以在 `app.ini` 的 `[repository.signing]` 部分找到：
 ```ini
 ...
 [repository.signing]
 SIGNING_KEY = default
 SIGNING_NAME =
 SIGNING_EMAIL =
 INITIAL_COMMIT = always
 CRUD_ACTIONS = pubkey, twofa, parentsigned
 WIKI = never
 MERGES = pubkey, twofa, basesigned, commitssigned
 ...
 ```
 ### `SIGNING_KEY`
 首先讨论的选项是 `SIGNING_KEY`。有三个主要选项：
 - `none` - 这将阻止 Gitea 对任何提交进行签名
 - `default` - Gitea 将使用 `git config` 中配置的默认密钥
 - `KEYID` - Gitea 将使用具有 ID `KEYID` 的 GPG 密钥对提交进行签名。在这种情况下，您应该提供 `SIGNING_NAME` 和 `SIGNING_EMAIL`，以便显示此密钥的信息。
 `default` 选项将读取 `git config` 中的 `commit.gpgsign` 选项 - 如果设置了该选项，它将使用 `user.signingkey`、`user.name` 和 `user.email` 的结果。
 请注意：通过在 Gitea 的仓库中调整 Git 的 `config` 文件，可以使用 `SIGNING_KEY=default` 为每个仓库提供不同的签名密钥。然而，这显然不是一个理想的用户界面，因此可能会发生更改。
 **自 1.17 起**，Gitea 在自己的主目录 `[git].HOME_PATH`（默认为 `%(APP_DATA_PATH)/home`）中运行 git，并使用自己的配置文件 `{[git].HOME_PATH}/.gitconfig`。
 如果您有自己定制的 Gitea git 配置，您应该将这些配置设置在系统 git 配置文件中（例如 `/etc/gitconfig`）或者 Gitea 的内部 git 配置文件 `{[git].HOME_PATH}/.gitconfig` 中。
 与 git 命令相关的主目录文件（如 `.gnupg`）也应该放在 Gitea 的 git 主目录 `[git].HOME_PATH` 中。
 如果您希望将 `.gnupg` 目录放在 `{[git].HOME_PATH}/` 之外的位置，请考虑设置 `$GNUPGHOME` 环境变量为您首选的位置。
 ### `INITIAL_COMMIT`
 此选项确定在创建仓库时，Gitea 是否应该对初始提交进行签名。可能的取值有：
 - `never`：从不签名
 - `pubkey`：仅在用户拥有公钥时进行签名
 - `twofa`：仅在用户使用 2FA 登录时进行签名
 - `always`：始终签名
 除了 `never` 和 `always` 之外的选项可以组合为逗号分隔的列表。如果所有选择的选项都为 true，则提交将被签名。
 ### `WIKI`
 此选项确定 Gitea 是否应该对 Wiki 的提交进行签名。可能的取值有：
 - `never`：从不签名
 - `pubkey`：仅在用户拥有公钥时进行签名
 - `twofa`：仅在用户使用 2FA 登录时进行签名
 - `parentsigned`：仅在父提交已签名时进行签名。
 - `always`：始终签名
 除了 `never` 和 `always` 之外的选项可以组合为逗号分隔的列表。如果所有选择的选项都为 true，则提交将被签名。
 ### `CRUD_ACTIONS`
 此选项确定 Gitea 是否应该对 Web 编辑器或 API CRUD 操作的提交进行签名。可能的取值有：
 - `never`：从不签名
 - `pubkey`：仅在用户拥有公钥时进行签名
 - `twofa`：仅在用户使用 2FA 登录时进行签名
 - `parentsigned`：仅在父提交已签名时进行签名。
 - `always`：始终签名
 除了 `never` 和 `always` 之外的选项可以组合为逗号分隔的列表。如果所有选择的选项都为 true，则更改将被签名。
 ### `MERGES`
 此选项确定 Gitea 是否应该对 PR 的合并提交进行签名。可能的选项有：
 - `never`：从不签名
 - `pubkey`：仅在用户拥有公钥时进行签名
 - `twofa`：仅在用户使用 2FA 登录时进行签名
 - `basesigned`：仅在基础仓库中的父提交已签名时进行签名。
 - `headsigned`：仅在头分支中的头提交已签名时进行签名。
 - `commitssigned`：仅在头分支中的所有提交到合并点的提交都已签名时进行签名。
 - `approved`：仅对已批准的合并到受保护分支的提交进行签名。
 - `always`：始终签名
 除了 `never` 和 `always` 之外的选项可以组合为逗号分隔的列表。如果所有选择的选项都为 true，则合并将被签名。
 ## 获取签名密钥的公钥
 用于签署 Gitea 提交的公钥可以通过 API 获取：
 ```sh
 /api/v1/signing-key.gpg
 ```
 在存在特定于仓库的密钥的情况下，可以通过以下方式获取：
 ```sh
 /api/v1/repos/:username/:reponame/signing-key.gpg
 ```
--- a/docs/content/doc/contributing/guidelines-backend.zh-cn.md
+++ b/docs/content/doc/contributing/guidelines-backend.zh-cn.md
@ -0,0 +1,123 @@
 ---
 date: "2023-05-25T23:41:00+08:00"
 title: "后端开发指南"
 slug: "guidelines-backend"
 weight: 20
 toc: false
 draft: false
 aliases:
  - /zh-cn/guidelines-backend
 menu:
  sidebar:
    parent: "contributing"
    name: "后端开发指南"
    weight: 20
    identifier: "guidelines-backend"
 ---
 # 后端开发指南
 **目录**
 {{< toc >}}
 ## 背景
 Gitea使用Golang作为后端编程语言。它使用了许多第三方包，并且自己也编写了一些包。
 例如，Gitea使用[Chi](https://github.com/go-chi/chi)作为基本的Web框架。[Xorm](https://xorm.io)是一个用于与数据库交互的ORM框架。
 因此，管理这些包非常重要。在开始编写后端代码之前，请参考以下准则。
 ## 包设计准则
 ### 包列表
 为了保持易于理解的代码并避免循环依赖，拥有良好的代码结构是很重要的。Gitea后端分为以下几个部分：
 - `build`：帮助构建Gitea的脚本。
 - `cmd`：包含所有Gitea的实际子命令，包括web、doctor、serv、hooks、admin等。`web`将启动Web服务。`serv`和`hooks`将被Git或OpenSSH调用。其他子命令可以帮助维护Gitea。
 - `tests`：常用的测试函数
 - `tests/integration`：集成测试，用于测试后端回归。
 - `tests/e2e`：端到端测试，用于测试前端和后端的兼容性和视觉回归。
 - `models`：包含由xorm用于构建数据库表的数据结构。它还包含查询和更新数据库的函数。应避免与其他Gitea代码的依赖关系。在某些情况下，比如日志记录时可以例外。
  - `models/db`：基本的数据库操作。所有其他`models/xxx`包都应依赖于此包。`GetEngine`函数只能从models/中调用。
  - `models/fixtures`：单元测试和集成测试中使用的示例数据。一个`yml`文件表示一个将在测试开始时加载到数据库中的表。
  - `models/migrations`：存储不同版本之间的数据库迁移。修改数据库结构的PR**必须**包含一个迁移步骤。
 - `modules`：在Gitea中处理特定功能的不同模块。工作正在进行中：其中一些模块应该移到`services`中，特别是那些依赖于models的模块，因为它们依赖于数据库。
  - `modules/setting`：存储从ini文件中读取的所有系统配置，并在各处引用。但是在可能的情况下，应将其作为函数参数使用。
  - `modules/git`：用于与`Git`命令行或Gogit包交互的包。
 - `public`：编译后的前端文件（JavaScript、图像、CSS等）
 - `routers`：处理服务器请求。由于它使用其他Gitea包来处理请求，因此其他包（models、modules或services）不能依赖于routers。
  - `routers/api`：包含`/api/v1`相关路由，用于处理RESTful API请求。
  - `routers/install`：只能在系统处于安装模式（INSTALL_LOCK=false）时响应。
  - `routers/private`：仅由内部子命令调用，特别是`serv`和`hooks`。
  - `routers/web`：处理来自Web浏览器或Git SMART HTTP协议的HTTP请求。
 - `services`：用于常见路由操作或命令执行的支持函数。使用`models`和`modules`来处理请求。
 - `templates`：用于生成HTML输出的Golang模板。
 ### 包依赖关系
 由于Golang不支持导入循环，我们必须仔细决定包之间的依赖关系。这些包之间有一些级别。以下是理想的包依赖关系方向。
 `cmd` -> `routers` -> `services` -> `models` -> `modules`
 从左到右，左侧的包可以依赖于右侧的包，但右侧的包不能依赖于左侧的包。在同一级别的子包中，可以根据该级别的规则进行依赖。
 **注意事项**
 为什么我们需要在`models`之外使用数据库事务？以及如何使用？
 某些操作在数据库记录插入/更新/删除失败时应该允许回滚。
 因此，服务必须能够创建数据库事务。以下是一些示例：
 ```go
 // services/repository/repository.go
 func CreateXXXX() error {
    return db.WithTx(func(ctx context.Context) error {
        // do something, if err is returned, it will rollback automatically
        if err := issues.UpdateIssue(ctx, repoID); err != nil {
            // ...
            return err
        }
        // ...
        return nil
    })
 }
 ```
 在`services`中**不应该**直接使用`db.GetEngine(ctx)`，而是应该在`models/`下编写一个函数。
 如果该函数将在事务中使用，请将`context.Context`作为函数的第一个参数。
 ```go
 // models/issues/issue.go
 func UpdateIssue(ctx context.Context, repoID int64) error {
    e := db.GetEngine(ctx)
    // ...
 }
 ```
 ### 包名称
 对于顶层包，请使用复数作为包名，例如`services`、`models`，对于子包，请使用单数，例如`services/user`、`models/repository`。
 ### 导入别名
 由于有一些使用相同包名的包，例如`modules/user`、`models/user`和`services/user`，当这些包在一个Go文件中被导入时，很难知道我们使用的是哪个包以及它是变量名还是导入名。因此，我们始终建议使用导入别名。为了与常见的驼峰命名法的包变量区分开，建议使用**snake_case**作为导入别名的命名规则。
 例如：`import user_service "code.gitea.io/gitea/services/user"`
 ### 重要注意事项
 - 永远不要写成`x.Update(exemplar)`，而没有明确的`WHERE`子句：
  - 这将导致表中的所有行都被使用exemplar的非零值进行更新，包括ID。
  - 通常应该写成`x.ID(id).Update(exemplar)`。
 - 如果在迁移过程中使用`x.Insert(exemplar)`向表中插入记录，而ID是预设的：
  - 对于MSSQL变体，你将需要执行``SET IDENTITY_INSERT `table` ON``（否则迁移将失败）
  - 对于PostgreSQL，你还需要更新ID序列，否则迁移将悄无声息地通过，但后续的插入将失败：
    ``SELECT setval('table_name_id_seq', COALESCE((SELECT MAX(id)+1 FROM `table_name`), 1), false)``
 ### 未来的任务
 目前，我们正在进行一些重构，以完成以下任务：
 - 纠正不符合规则的代码。
 - `models`中的文件太多了，所以我们正在将其中的一些移动到子包`models/xxx`中。
 - 由于它们依赖于`models`，因此应将某些`modules`子包移动到`services`中。
--- a/docs/content/doc/contributing/guidelines-frontend.zh-cn.md
+++ b/docs/content/doc/contributing/guidelines-frontend.zh-cn.md
@ -0,0 +1,138 @@
 ---
 date: "2023-05-25T16:00:00+02:00"
 title: "前端开发指南"
 slug: "guidelines-frontend"
 weight: 20
 toc: false
 draft: false
 aliases:
  - /zh-cn/guidelines-frontend
 menu:
  sidebar:
    parent: "contributing"
    name: "前端开发指南"
    weight: 20
    identifier: "guidelines-frontend"
 ---
 # 前端开发指南
 **目录**
 {{< toc >}}
 ## 背景
 Gitea 在其前端中使用[Fomantic-UI](https://fomantic-ui.com/introduction/getting-started.html)（基于[jQuery](https://api.jquery.com)）和 [Vue3](https://vuejs.org/)。
 HTML 页面由[Go HTML Template](https://pkg.go.dev/html/template)渲染。
 源文件可以在以下目录中找到：
 * **CSS 样式**： `web_src/css/`
 * **JavaScript 文件**： `web_src/js/`
 * **Vue 组件**： `web_src/js/components/`
 * **Go HTML 模板**： `templates/`
 ## 通用准则
 我们推荐使用[Google HTML/CSS Style Guide](https://google.github.io/styleguide/htmlcssguide.html)和[Google JavaScript Style Guide](https://google.github.io/styleguide/jsguide.html)。
 ## Gitea 特定准则：
 1. 每个功能（Fomantic-UI/jQuery 模块）应放在单独的文件/目录中。
 2. HTML 的 id 和 class 应使用 kebab-case，最好包含2-3个与功能相关的关键词。
 3. 在 JavaScript 中使用的 HTML 的 id 和 class 应在整个项目中是唯一的，并且应包含2-3个与功能相关的关键词。建议在仅在 JavaScript 中使用的 class 中使用 `js-` 前缀。
 4. 不应覆盖框架提供的 class 的 CSS 样式。始终使用具有2-3个与功能相关的关键词的新 class 名称来覆盖框架样式。Gitea 中的帮助 CSS 类在 `helpers.less` 中。
 5. 后端可以通过使用`ctx.PageData["myModuleData"] = map[]{}`将复杂数据传递给前端，但不要将整个模型暴露给前端，以避免泄露敏感数据。
 6. 简单页面和与 SEO 相关的页面使用 Go HTML 模板渲染生成静态的 Fomantic-UI HTML 输出。复杂页面可以使用 Vue3。
 7. 明确变量类型，优先使用`elem.disabled = true`而不是`elem.setAttribute('disabled', 'anything')`，优先使用`$el.prop('checked', var === 'yes')`而不是`$el.prop('checked', var)`。
 8. 使用语义化元素，优先使用`<button class="ui button">`而不是`<div class="ui button">`。
 9. 避免在 CSS 中使用不必要的`!important`，如果无法避免，添加注释解释为什么需要它。
 10. 避免在一个事件监听器中混合不同的事件，优先为每个事件使用独立的事件监听器。
 11. 推荐使用自定义事件名称前缀`ce-`。
 12. Gitea 的 tailwind-style CSS 类使用`gt-`前缀（`gt-relative`），而 Gitea 自身的私有框架级 CSS 类使用`g-`前缀（`g-modal-confirm`）。
 ### 可访问性 / ARIA
 在历史上，Gitea大量使用了可访问性不友好的框架 Fomantic UI。
 Gitea使用一些补丁使Fomantic UI更具可访问性（参见`aria.js`和`aria.md`），
 但仍然存在许多问题需要大量的工作和时间来修复。
 ### 框架使用
 不建议混合使用不同的框架，这会使代码难以维护。
 一个 JavaScript 模块应遵循一个主要框架，并遵循该框架的最佳实践。
 推荐的实现方式：
 * Vue + Vanilla JS
 * Fomantic-UI（jQuery）
 * Vanilla JS
 不推荐的实现方式：
 * Vue + Fomantic-UI（jQuery）
 * jQuery + Vanilla JS
 为了保持界面一致，Vue 组件可以使用 Fomantic-UI 的 CSS 类。
 尽管不建议混合使用不同的框架，
 但如果混合使用是必要的，并且代码设计良好且易于维护，也可以工作。
 ### async 函数
 只有当函数内部存在`await`调用或返回`Promise`时，才将函数标记为`async`。
 不建议使用`async`事件监听器，这可能会导致问题。
 原因是`await`后的代码在事件分发之外执行。
 参考：https://github.com/github/eslint-plugin-github/blob/main/docs/rules/async-preventdefault.md
 如果一个事件监听器必须是`async`，应在任何`await`之前使用`e.preventDefault()`，
 建议将其放在函数的开头。
 如果我们想在非异步上下文中调用`async`函数，
 建议使用`const _promise = asyncFoo()`来告诉读者
 这是有意为之的，我们想调用异步函数并忽略Promise。
 一些 lint 规则和 IDE 也会在未处理返回的 Promise 时发出警告。
 ### HTML 属性和 dataset
 禁止使用`dataset`，它的驼峰命名行为使得搜索属性变得困难。
 然而，仍然存在一些特殊情况，因此当前的准则是：
 * 对于旧代码：
  * 应将`$.data()`重构为`$.attr()`。
  * 在极少数情况下，可以使用`$.data()`将一些非字符串数据绑定到元素上，但强烈不推荐使用。
 * 对于新代码：
  * 不应使用`node.dataset`，而应使用`node.getAttribute`。
  * 不要将任何用户数据绑定到 DOM 节点上，使用合适的设计模式描述节点和数据之间的关系。
 ### 显示/隐藏元素
 * 推荐在Vue组件中使用`v-if`和`v-show`来显示/隐藏元素。
 * Go 模板代码应使用 Gitea 的 `.gt-hidden` 和 `showElem()/hideElem()/toggleElem()` 来显示/隐藏元素，请参阅`.gt-hidden`的注释以获取更多详细信息。
 ### Go HTML 模板中的样式和属性
 建议使用以下方式：
 ```html
 <div class="gt-name1 gt-name2 {{if .IsFoo}}gt-foo{{end}}" {{if .IsFoo}}data-foo{{end}}></div>
 ```
 而不是：
 ```html
 <div class="gt-name1 gt-name2{{if .IsFoo}} gt-foo{{end}}"{{if .IsFoo}} data-foo{{end}}></div>
 ```
 以使代码更易读。
 ### 旧代码
 许多旧代码已经存在于本文撰写之前。建议重构旧代码以遵循指南。
 ### Vue3 和 JSX
 Gitea 现在正在使用 Vue3。我们决定不引入 JSX，以保持 HTML 代码和 JavaScript 代码分离。
--- a/docs/content/doc/contributing/guidelines-refactoring.zh-cn.md
+++ b/docs/content/doc/contributing/guidelines-refactoring.zh-cn.md
@ -0,0 +1,53 @@
 ---
 date: "2023-05-25T00:00:00+00:00"
 title: "重构指南"
 slug: "guidelines-refactoring"
 weight: 20
 toc: false
 draft: false
 aliases:
  - /zh-cn/guidelines-refactoring
 menu:
  sidebar:
    parent: "contributing"
    name: "重构指南"
    weight: 20
    identifier: "guidelines-refactoring"
 ---
 # 重构指南
 **目录**
 {{< toc >}}
 ## 背景
 自2014年2月12日编写了第一行代码以来，Gitea已经发展成为一个庞大的项目。
 因此，代码库变得越来越大。代码库越大，维护就越困难。
 存在许多过时的机制，许多框架混合在一起，一些遗留代码可能会导致错误并阻碍新功能的开发。
 为了使代码库更易于维护，使Gitea变得更好，开发人员应牢记使用现代机制来重构旧代码。
 本文档是关于重构代码库的指南集合。
 ## 重构建议
 * 设计更多关于未来的内容，而不仅仅解决当前问题。
 * 减少模糊性，减少冲突，提高可维护性。
 * 描述重构，例如：
  * 为什么需要重构。
  * 如何解决旧问题。
  * 重构的优点/缺点是什么。
 * 只做必要的更改，尽量保留旧逻辑。
 * 引入一些中间步骤，使重构更容易审查，完整的重构计划可以在几个PR中完成。
 * 如果存在分歧，应该请TOC（技术监督委员会）参与决策。
 * 添加必要的测试以确保重构的正确性。
 * 非错误重构优先在里程碑的开始时进行，这样可以更容易地在发布之前发现问题。
 ## 审查和合并建议
 * 重构的PR不应该长时间保持打开状态（通常为7天），应尽快进行审查。
 * 重构的PR应尽快合并，不应被其他PR阻塞。
 * 如果TOC没有异议，重构的PR可以在7天后由一名核心成员（非作者）批准后合并。
 * 如果最终结果良好，容忍一些不完美/临时的步骤。
 * 如果重构是必要的，容忍一些回归错误，并尽快修复错误。
--- a/docs/content/doc/contributing/translation.zh-cn.md
+++ b/docs/content/doc/contributing/translation.zh-cn.md
@ -0,0 +1,17 @@
 ---
 date: "2023-05-25T00:00:00+02:00"
 title: "翻译指南"
 weight: 70
 toc: true
 draft: false
 menu:
  sidebar:
    parent: "contributing"
    name: "翻译指南"
    weight: 70
    identifier: "translation-guidelines"
 ---
 本页面用于提供一套通用规则，以确保翻译的一致性。
 * [German](/de-de/übersetzungs-richtlinien/)
--- a/docs/content/doc/development/integrations.zh-cn.md
+++ b/docs/content/doc/development/integrations.zh-cn.md
@ -0,0 +1,46 @@
 ---
 date: "2023-05-25T17:29:00+08:00"
 title: "集成"
 slug: "integrations"
 weight: 65
 toc: false
 draft: false
 aliases:
  - /zh-cn/integrations
 menu:
  sidebar:
    parent: "development"
    name: "集成"
    weight: 65
    identifier: "integrations"
 ---
 # 集成
 Gitea拥有一个出色的第三方集成社区，以及在其他各种项目中的一流支持。
 我们正在[awesome-gitea](https://gitea.com/gitea/awesome-gitea)上整理一个列表来跟踪这些集成！
 如果你正在寻找[CI/CD](https://gitea.com/gitea/awesome-gitea#user-content-devops)，
 一个[SDK](https://gitea.com/gitea/awesome-gitea#user-content-sdk)，
 甚至一些额外的[主题](https://gitea.com/gitea/awesome-gitea#user-content-themes)，
 你可以在[awesome-gitea](https://gitea.com/gitea/awesome-gitea)中找到它们的列表！
 ## 预填新文件名和内容
 如果你想打开一个具有给定名称和内容的新文件，
 你可以使用查询参数来实现：
 ```txt
 GET /{{org}}/{{repo}}/_new/{{filepath}}
    ?filename={{filename}}
    &value={{content}}
 ```
 例如：
 ```txt
 GET https://git.example.com/johndoe/bliss/_new/articles/
    ?filename=hello-world.md
    &value=Hello%2C%20World!
 ```
--- a/docs/content/doc/development/migrations.zh-cn.md
+++ b/docs/content/doc/development/migrations.zh-cn.md
@ -0,0 +1,40 @@
 ---
 date: "2023-05-25T17:29:00+08:00"
 title: "迁移界面"
 slug: "migrations-interfaces"
 weight: 55
 toc: false
 draft: false
 aliases:
  - /zh-cn/migrations-interfaces
 menu:
  sidebar:
    parent: "development"
    name: "迁移界面"
    weight: 55
    identifier: "migrations-interfaces"
 ---
 # 迁移功能
 完整迁移功能在Gitea 1.9.0版本中引入。它定义了两个接口，用于支持从其他Git托管平台迁移存储库数据到Gitea，或者在将来将Gitea数据迁移到其他Git托管平台。
 目前已实现了从GitHub、GitLab和其他Gitea实例的迁移。
 首先，Gitea在包[modules/migration](https://github.com/go-gitea/gitea/tree/main/modules/migration)中定义了一些标准对象。它们是`Repository`、`Milestone`、`Release`、`ReleaseAsset`、`Label`、`Issue`、`Comment`、`PullRequest`、`Reaction`、`Review`、`ReviewComment`。
 ## 下载器接口
 要从新的Git托管平台迁移，需要进行两个步骤的更新。
 - 您应该实现一个`Downloader`，用于获取存储库信息。
 - 您应该实现一个`DownloaderFactory`，用于检测URL是否匹配，并创建上述的`Downloader`。
  - 您需要在`init()`中通过`RegisterDownloaderFactory`注册`DownloaderFactory`。
 您可以在[downloader.go](https://github.com/go-gitea/gitea/blob/main/modules/migration/downloader.go)中找到这些接口。
 ## 上传器接口
 目前，只实现了`GiteaLocalUploader`，因此我们只能通过此Uploader将下载的数据保存到本地的Gitea实例。目前不支持其他上传器。
 您可以在[uploader.go](https://github.com/go-gitea/gitea/blob/main/modules/migration/uploader.go)中找到这些接口。
--- a/docs/content/doc/help/faq.zh-cn.md
+++ b/docs/content/doc/help/faq.zh-cn.md
@ -0,0 +1,472 @@
 ---
 date: "2023-05-25T16:00:00+02:00"
 title: "常见问题"
 slug: "faq"
 weight: 5
 toc: false
 draft: false
 aliases:
  - /zh-cn/faq
 menu:
  sidebar:
    parent: "help"
    name: "常见问题"
    weight: 5
    identifier: "faq"
 ---
 # 常见问题 <!-- omit in toc -->
 本页面包含一些常见问题和答案。
 有关更多帮助资源，请查看所有[支持选项]({{< relref "doc/help/seek-help.zh-cn.md" >}})。
 **目录**
 {{< toc >}}
 ## 1.x和1.x.x下载之间的区别
 以1.7.x版本为例。
 **注意：**此示例也适用于Docker镜像！
 在我们的[下载页面](https://dl.gitea.io/gitea/)上，您会看到一个1.7目录，以及1.7.0、1.7.1、1.7.2、1.7.3、1.7.4、1.7.5和1.7.6的目录。
 1.7目录和1.7.0目录是**不同**的。1.7目录是在每个合并到[`release/v1.7`](https://github.com/go-gitea/gitea/tree/release/v1.7)分支的提交上构建的。
 然而，1.7.0目录是在创建[`v1.7.0`](https://github.com/go-gitea/gitea/releases/tag/v1.7.0)标签时创建的构建。
 这意味着1.x的下载会随着提交合并到各自的分支而改变（将其视为每个版本的单独的“main”分支）。
 另一方面，1.x.x的下载应该永远不会改变。
 ## 如何从Gogs/GitHub等迁移到Gitea
 要从Gogs迁移到Gitea：
 - [Gogs版本0.9.146或更低]({{< relref "doc/installation/upgrade-from-gogs.zh-cn.md" >}})
 - [Gogs版本0.11.46.0418](https://github.com/go-gitea/gitea/issues/4286)
 要从GitHub迁移到Gitea，您可以使用Gitea内置的迁移表单。
 为了迁移诸如问题、拉取请求等项目，您需要至少输入您的用户名。
 [Example (requires login)](https://try.gitea.io/repo/migrate)
 要从GitLab迁移到Gitea，您可以使用这个非关联的工具：
 https://github.com/loganinak/MigrateGitlabToGogs
 ## Gitea存储文件的位置
 - _`AppWorkPath`_
  - `--work-path`标志
  - 或者环境变量`GITEA_WORK_DIR`
  - 或者在构建时设置的内置值
  - 或者包含Gitea二进制文件的目录
 - `%(APP_DATA_PATH)`（数据库、索引器等的默认路径）
  - `app.ini`中的`APP_DATA_PATH`
  - 或者_`AppWorkPath`_`/data`
 - _`CustomPath`_（自定义模板）
  - `--custom-path`标志
  - 或者环境变量`GITEA_CUSTOM`
  - 或者在构建时设置的内置值
  - 或者_`AppWorkPath`_`/custom`
 - HomeDir
  - Unix：环境变量`HOME`
  - Windows：环境变量`USERPROFILE`，或者环境变量`HOMEDRIVE`+`HOMEPATH`
 - RepoRootPath
  - `app.ini`中\[repository]部分的`ROOT`（如果是绝对路径）
  - 否则_`AppWorkPath`_`/ROOT`(如果`app.ini`中\[repository]部分的`ROOT`是相对路径）
  - 默认值为`%(APP_DATA_PATH)/gitea-repositories`
 - INI（配置文件）
  - `--config`标志
  - 或者在构建时设置的可能内置值
  - 或者 _`CustomPath`_`/conf/app.ini`
 - SQLite数据库
  - app.ini中database部分的PATH
  - 或者`%(APP_DATA_PATH)/gitea.db`
 ## 看不到克隆URL或克隆URL不正确
 有几个地方可能会导致显示不正确。
 1. 如果使用反向代理，请确保按照[反向代理指南]({{< relref "doc/administration/reverse-proxies.zh-cn.md" >}})中的正确说明进行设置。
 2. 确保在`app.ini`的`server`部分中正确设置了`ROOT_URL`。
 如果某些克隆选项未显示（HTTP/S或SSH），可以在`app.ini中`
 - `DISABLE_HTTP_GIT`: 如果设为true, 将会没有HTTP/HTTPS链接
 - `DISABLE_SSH`: 如果设为true, 将会没有SSH链接
 - `SSH_EXPOSE_ANONYMOUS`: 如果设为false, SSH链接将会对匿名用户隐藏
 ## 文件上传失败：413 Request Entity Too Large
 当反向代理限制文件上传大小时，会出现此错误。
 有关使用nginx解决此问题，请参阅[反向代理指南]({{< relref "doc/administration/reverse-proxies.zh-cn.md" >}})。
 ## 自定义模板无法加载或运行错误
 Gitea的自定义模板必须将其添加到正确的位置，否则Gitea将无法找到并使用自定义模板。
 模板的正确路径应该相对于`CustomPath`。
 1. 要找到`CustomPath`，请在站点管理 -> 配置 中查找自定义文件根路径。
    如果找不到，请尝试`echo $GITEA_CUSTOM`。
 2. 如果仍然找不到，默认值可以被[计算]({{< relref "doc/help/faq.zh-cn.md#where-does-gitea-store-what-file" >}})
 3. 如果仍然找不到路径，则可以参考[自定义Gitea]({{< relref "doc/administration/customizing-gitea.zh-cn.md" >}})页面，将模板添加到正确的位置。
 ## Gitea是否有"GitHub/GitLab Pages"功能？
 Gitea不提供内置的Pages服务器。您需要一个专用的域名来提供静态页面，以避免CSRF安全风险。
 对于简单的用法，您可以使用反向代理来重写和提供Gitea的原始文件URL中的静态内容。
 还有一些已经可用的第三方服务，比如独立[pages server](https://codeberg.org/Codeberg/pages-server)的或[caddy plugin](https://github.com/42wim/caddy-gitea)，可以提供所需的功能。
 ## 活跃用户与禁止登录用户
 在Gitea中，"活跃用户"是指通过电子邮件激活其帐户的用户。
 "禁止登录用户"是指不允许再登录到Gitea的用户。
 ## 设置日志记录
 - [官方文档]({{< relref "doc/administration/logging-config.zh-cn.md" >}})
 ## 什么是Swagger？
 [Swagger](https://swagger.io/) 是Gitea用于其API文档的工具。
 所有Gitea实例都有内置的API，无法完全禁用它。
 但是，您可以在app.ini的api部分将ENABLE_SWAGGER设置为false，以禁用其文档显示。
 有关更多信息，请参阅Gitea的[API文档]({{< relref "doc/development/api-usage.zh-cn.md" >}})。
 您可以在上查看最新的API（例如）<https://try.gitea.io/api/swagger>。
 您还可以在上查看`swagger.json`文件的示例 <https://try.gitea.io/swagger.v1.json>。
 ## 调整服务器用于公共/私有使用
 ### 防止垃圾邮件发送者
 有多种方法可以组合使用来防止垃圾邮件发送者：
 1. 通过设置电子邮件域名的白名单或黑名单。
 2. 通过设置一些域名或者OpenID白名单（见下文）。
 3. 在您的`app.ini`中将`ENABLE_CAPTCHA`设置为`true`，并正确配置`RECAPTCHA_SECRET`和 `RECAPTCHA_SITEKEY`。
 4. 将`DISABLE_REGISTRATION`设置为`true`，并通过 [CLI]({{< relref "doc/administration/command-line.zh-cn.md" >}})、[API]({{< relref "doc/development/api-usage.zh-cn.md" >}}) 或 Gitea 的管理界面创建新用户。
 ### 仅允许/阻止特定的电子邮件域名
 您可以在`app.ini`中的`[service]`下的配置`EMAIL_DOMAIN_WHITELIST` 或 `EMAIL_DOMAIN_BLOCKLIST`。
 ### 仅允许/阻止特定的 OpenID 提供商
 您可以在`app.ini`的`[openid]`下配置`WHITELISTED_URI`或`BLACKLISTED_URIS`。
 **注意**： 白名单优先，如果白名单非空，则忽略黑名单。
 ### 仅允许发布问题的用户
 目前实现这一点的方法是创建/修改一个具有最大仓库创建限制为 0 的用户。
 ### 受限制的用户
 受限制的用户仅能访问其组织/团队成员和协作所在的内容的子集，而忽略组织/仓库等的公共标志。
 示例用例：一个公司运行一个需要登录的 Gitea 实例。大多数仓库是公开的（所有同事都可以访问/浏览）。
 在某些情况下，某个客户或第三方需要访问特定的仓库，并且只能访问该仓库。通过将此类客户帐户设置为受限制帐户，并使用团队成员身份和/或协作来授予所需的任何访问权限，可以简单地实现这一点，而无需使所有内容都变为私有。
 ### 启用 Fail2ban
 使用 [Fail2Ban]({{< relref "doc/administration/fail2ban-setup.zh-cn.md" >}}) 监视并阻止基于日志模式的自动登录尝试或其他恶意行为。
 ## 如何添加/使用自定义主题
 Gitea 目前支持三个官方主题，分别是 `gitea`（亮色）、`arc-green`（暗色）和 `auto`（根据操作系统设置自动切换前两个主题）。
 要添加自己的主题，目前唯一的方法是提供一个完整的主题（不仅仅是颜色覆盖）。
 假设我们的主题是 `arc-blue`（这是一个真实的主题，可以在[此问题](https://github.com/go-gitea/gitea/issues/6011)中找到）
 将`.css`文件命名为`theme-arc-blue.css`并将其添加到`custom/public/css`文件夹中
 通过将`arc-blue`添加到`app.ini`中的`THEMES`列表中，允许用户使用该主题
 ## SSHD vs 内建SSH
 SSHD是大多数Unix系统上内建的SSH服务器。
 Gitea还提供了自己的SSH服务器，用于在SSHD不可用时使用。
 ## Gitea运行缓慢
 导致此问题的最常见原因是加载联合头像。
 您可以通过在`app.ini`中将`ENABLE_FEDERATED_AVATAR`设置为`false`来关闭此功能。
 还有一个可能需要更改的选项是在`app.ini`中将`DISABLE_GRAVATAR`设置为`true`。
 ## 无法创建仓库/文件
 请确保Gitea具有足够的权限来写入其主目录和数据目录。
 参见[AppDataPath 和 RepoRootPath]({{< relref "doc/help/faq.zh-cn.md#where-does-gitea-store-what-file" >}})
 **适用于Arch用户的注意事项：**在撰写本文时，Arch软件包的systemd文件包含了以下行：
 `ReadWritePaths=/etc/gitea/app.ini`
 这将使得Gitea无法写入其他路径。
 ## 翻译不正确/如何添加更多翻译
 我们当前的翻译是在我们的[Crowdin项目](https://crowdin.com/project/gitea)上众包进行的
 无论您想要更改翻译还是添加新的翻译，都需要在Crowdin集成中进行，因为所有翻译都会被CI覆盖。
 ## 推送钩子/ Webhook未运行
 如果您可以推送但无法在主页仪表板上看到推送活动，或者推送不触发Webhook，有几种可能性：
 1. Git钩子不同步：在站点管理面板上运行“重新同步所有仓库的pre-receive、update和post-receive钩子”
 2. Git仓库（和钩子）存储在一些不支持脚本执行的文件系统上（例如由NAS挂载），请确保文件系统支持`chmod a+x any-script`
 3. 如果您使用的是Docker，请确保Docker Server（而不是客户端）的版本 >= 20.10.6
 ## SSH问题
 如果无法通过`ssh`访问仓库，但`https`正常工作，请考虑以下情况。
 首先，请确保您可以通过SSH访问Gitea。
 `ssh git@myremote.example`
 如果连接成功，您应该会收到以下错误消息：
 ```
 Hi there, You've successfully authenticated, but Gitea does not provide shell access.
 If this is unexpected, please log in with password and setup Gitea under another user.
 ```
 如果您收到以上消息但仍然连接成功，这意味着您的 SSH 密钥**没有**由 Gitea 管理。这意味着钩子不会运行，在其他一些潜在问题中也包括在内。
 如果您无法连接，可能是因为您的 SSH 密钥在本地配置不正确。
 这是针对 SSH 而不是 Gitea 的问题，因此在此不涉及。
 ### SSH 常见错误
 ```
 Permission denied (publickey).
 fatal: Could not read from remote repository.
 ```
 此错误表示服务器拒绝登录尝试，
 请检查以下事项：
 - 在客户端：
  - 确保公钥和私钥已添加到正确的 Gitea 用户。
  - 确保远程 URL 中没有任何问题。特别是，请确保∂
  Git 用户（@ 之前的部分）的名称拼写正确。
  - 确保客户端机器上的公钥和私钥正确无误。
 - 在服务器上：
  - 确保存储库存在并且命名正确。
  - 检查系统用户主目录中的 `.ssh` 目录的权限。
  - 验证正确的公钥是否已添加到 `.ssh/authorized_keys` 中。
  尝试在 Gitea 管理面板上运行
  `Rewrite '.ssh/authorized_keys' file (for Gitea SSH keys)`。
 - 查看 Gitea 日志。
 - 查看 /var/log/auth（或类似的文件）。
 - 检查存储库的权限。
 以下是一个示例，其中缺少公共 SSH 密钥，
 认证成功，但是其他设置导致 SSH 无法访问正确的
 存储库。
 ```
 fatal: Could not read from remote repository.
 Please make sure you have the correct access rights
 and the repository exists.
 ```
 在这种情况下，请检查以下设置：
 - 在服务器上：
  - 确保`git`系统用户设置了可用的 shell
    - 使用`getent passwd git | cut -d: -f7`进行验证
    - 可以使用`usermod`或`chsh`进行修改。
  - 确保`.ssh/authorized_keys`中的`gitea serv`命令使用
    正确的配置文件。
 ## 迁移带有标签的存储库后缺失发布版本
 要迁移带有所有标签的存储库，您需要执行两个操作：
 - 推送标签到存储库：
 ```
 git push --tags
 ```
 - 在 Gitea 中重新同步所有存储库的标签：
 ```
 gitea admin repo-sync-releases
 ```
 ## LFS 问题
 针对涉及 LFS 数据上传的问题
 ```
 batch response: Authentication required: Authorization error: <GITEA_LFS_URL>/info/lfs/objects/batch
 Check that you have proper access to the repository
 error: failed to push some refs to '<GIT_REPO_URL>'
 ```
 检查`app.ini`文件中的`LFS_HTTP_AUTH_EXPIRY`值。
 默认情况下，LFS 令牌在 20 分钟后过期。如果您的连接速度较慢或文件较大（或两者都是），可能无法在时间限制内完成上传。
 您可以将此值设置为`60m`或`120m`。
 ## 如何在启动 Gitea 之前创建用户
 Gitea 提供了一个子命令`gitea migrate`来初始化数据库，然后您可以使用[管理 CLI 命令]({{< relref "doc/administration/command-line.zh-cn.md#admin" >}})像正常情况下添加用户。
 ## 如何启用密码重置
 没有密码重置的设置。当配置了[邮件服务]({{< relref "doc/administration/email-setup.zh-cn.md" >}})时，密码重置将自动启用；否则将被禁用。
 ## 如何更改用户的密码
 - 作为管理员，您可以更改任何用户的密码（并可选择强制其在下次登录时更改密码）...
  - 转到您的`站点管理 -> 用户账户`页面并编辑用户。
 - 使用[管理 CLI 命令]({{< relref "doc/administration/command-line.zh-cn.md#admin" >}})。
  请注意，大多数命令还需要一个[全局标志]({{< relref "doc/administration/command-line.zh-cn.- md#global-options" >}})来指向正确的配置。
 - 作为**用户**，您可以更改密码...
  - 在您的账户的`设置 -> 账户`页面（此方法**需要**您知道当前密码）。
  - 使用`忘记密码`链接。
  如果`忘记密码/账户恢复`页面被禁用，请联系管理员配置[邮件服务]({{< relref "doc/administration/email-setup.zh-cn.md" >}})。
 ## 为什么我的 Markdown 显示错误
 在 Gitea 版本 `1.11` 中，我们转换为使用[goldmark](https://github.com/yuin/goldmark)进行 Markdown 渲染，它符合[CommonMark](https://commonmark.org/)标准。
 如果您在版本`1.11`之前的Markdown正常工作，但在升级后无法正常工作，请仔细阅读CommonMark规范，看看问题是由错误还是非兼容的语法引起的。
 如果是后者，通常规范中会列出一种符合标准的替代方法。
 ## 使用 MySQL 进行升级时出现的错误
 如果在使用 MySQL 升级 Gitea 时收到以下错误：
 > `ORM engine initialization failed: migrate: do migrate: Error: 1118: Row size too large...`
 请运行`gitea convert`或对数据库中的每个表运行`ALTER TABLE table_name ROW_FORMAT=dynamic;`。
 潜在问题是默认行格式分配给每个表的索引空间
 太小。Gitea 要求其表的`ROWFORMAT`为`DYNAMIC`。
 如果收到包含`Error 1071: Specified key was too long; max key length is 1000 bytes...`
 的错误行，则表示您正在尝试在使用 ISAM 引擎的表上运行 Gitea。尽管在先前版本的 Gitea 中可能是凑巧能够工作的，但它从未得到官方支持，
 您必须使用 InnoDB。您应该对数据库中的每个表运行`ALTER TABLE table_name ENGINE=InnoDB;`。
 如果您使用的是 MySQL 5，另一个可能的修复方法是：
 ```mysql
 SET GLOBAL innodb_file_format=Barracuda;
 SET GLOBAL innodb_file_per_table=1;
 SET GLOBAL innodb_large_prefix=1;
 ```
 ## 为什么 MySQL 上的 Emoji 显示错误
 不幸的是，MySQL 的`utf8`字符集不完全允许所有可能的 UTF-8 字符，特别是 Emoji。
 他们创建了一个名为 `utf8mb4`的字符集和校对规则，允许存储 Emoji，但使用
 utf8 字符集的表和连接将不会使用它。
 请运行 `gitea convert` 或对数据库运行`ALTER DATABASE database_name CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;`
 并对每个表运行
 `ALTER TABLE table_name CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;`。
 您还需要将`app.ini`文件中的数据库字符集设置为`CHARSET=utf8mb4`。
 ## 为什么 Emoji 只显示占位符或单色图像
 Gitea 需要系统或浏览器安装其中一个受支持的 Emoji 字体，例如 Apple Color Emoji、Segoe UI Emoji、Segoe UI Symbol、Noto Color Emoji 和 Twemoji Mozilla。通常，操作系统应该已经提供了其中一个字体，但特别是在 Linux 上，可能需要手动安装它们。
 ## SystemD 和 Docker 上的标准输出日志
 SystemD 上的标准输出默认会写入日志记录中。您可以尝试使用 `journalctl`、`journalctl -u gitea` 或 `journalctl <path-to-gitea-binary>`来查看。
 类似地，Docker 上的标准输出可以使用`docker logs <container>`来查看。
 要收集日志以进行帮助和问题报告，请参阅[支持选项]({{< relref "doc/help/seek-help.zh-cn.md" >}})。
 ## 初始日志记录
 在 Gitea 读取配置文件并设置其日志记录之前，它会将一些内容记录到标准输出，以帮助调试日志记录无法工作的情况。
 您可以通过设置`--quiet`或`-q`选项来停止此日志记录。请注意，这只会在 Gitea 设置自己的日志记录之前停止日志记录。
 如果您报告了错误或问题，必须提供这些信息以恢复初始日志记录。
 只有在完全配置了所有内容之后，您才应该设置此选项。
 ## 在数据库启动期间出现有关结构默认值的警告
 有时，在迁移过程中，旧列和默认值可能在数据库架构中保持不变。
 这可能会导致警告，例如：
 ```
 2020/08/02 11:32:29 ...rm/session_schema.go:360:Sync2() [W] Table user Column keep_activity_private db default is , struct default is 0
 ```
 可以安全地忽略这些警告，但您可以通过让 Gitea 重新创建这些表来停止这些警告，使用以下命令：
 ```
 gitea doctor recreate-table user
 ```
 这将导致 Gitea 重新创建用户表并将旧数据复制到新表中，
 并正确设置默认值。
 您可以使用以下命令要求 Gitea 重新创建多个表：
 ```
 gitea doctor recreate-table table1 table2 ...
 ```
 如果您希望 Gitea 重新创建所有表，请使用以下命令：
 ```
 gitea doctor recreate-table
 ```
 在运行这些命令之前，强烈建议您备份数据库。
 ## 为什么查看文件时制表符/缩进显示错误
 如果您正在使用 Cloudflare，请在仪表板中关闭自动缩小选项。
 `Speed` -> `Optimization` -> 在 `Auto-Minify` 设置中取消选中 `HTML`。
 ## 如何从磁盘采用存储库
 - 将您的（裸）存储库添加到正确的位置，即您的配置所在的地方（`repository.ROOT`），确保它们位于正确的布局`<REPO_ROOT>/[user]/[repo].git`。
  - **注意：**目录名必须为小写。
  - 您还可以在`<ROOT_URL>/admin/config`中检查存储库根路径。
 - 确保存在要采用存储库的用户/组织。
 - 作为管理员，转到`<ROOT_URL>/admin/repos/unadopted`并搜索。
 - 用户也可以通过配置[`ALLOW_ADOPTION_OF_UNADOPTED_REPOSITORIES`]({{< relref "doc/administration/config-cheat-sheet.zh-cn.md#repository" >}}) 获得类似的权限。
 - 如果上述步骤都正确执行，您应该能够选择要采用的存储库。
  - 如果没有找到存储库，请启用[调试日志记录]({{< relref "doc/administration/config-cheat-sheet.zh-cn.md#repository" >}})以检查是否有特定错误。
--- a/docs/content/doc/installation/database-preparation.zh-cn.md
+++ b/docs/content/doc/installation/database-preparation.zh-cn.md
@ -0,0 +1,307 @@
 ---
 date: "2020-01-16"
 title: "数据库准备"
 slug: "database-prep"
 weight: 10
 toc: false
 draft: false
 aliases:
  - /zh-cn/database-prep
 menu:
  sidebar:
    parent: "installation"
    name: "数据库准备"
    weight: 10
    identifier: "database-prep"
 ---
 # 数据库准备
 在使用 Gitea 前，您需要准备一个数据库。Gitea 支持 PostgreSQL（>=10）、MySQL（>=5.7）、SQLite 和 MSSQL（>=2008R2 SP3）这几种数据库。本页将指导您准备数据库。由于 PostgreSQL 和 MySQL 在生产环境中被广泛使用，因此本文档将仅涵盖这两种数据库。如果您计划使用 SQLite，则可以忽略本章内容。
 数据库实例可以与 Gitea 实例在相同机器上（本地数据库），也可以与 Gitea 实例在不同机器上（远程数据库）。
 注意：以下所有步骤要求您的选择的数据库引擎已安装在您的系统上。对于远程数据库设置，请在数据库实例上安装服务器应用程序，在 Gitea 服务器上安装客户端程序。客户端程序用于测试 Gitea 服务器与数据库之间的连接，而 Gitea 本身使用 Go 提供的数据库驱动程序完成相同的任务。此外，请确保服务器和客户端使用相同的引擎版本，以使某些引擎功能正常工作。出于安全原因，请使用安全密码保护 `root`（MySQL）或 `postgres`（PostgreSQL）数据库超级用户。以下步骤假设您在数据库和 Gitea 服务器上都使用 Linux。
 **目录**
 {{< toc >}}
 ## MySQL
 1. 对于远程数据库设置，您需要让 MySQL 监听您的 IP 地址。编辑数据库实例上的 `/etc/mysql/my.cnf` 文件中的 `bind-address` 选项为：
    ```ini
    bind-address = 203.0.113.3
    ```
 2. 在数据库实例上，使用 `root` 用户登录到数据库控制台：
    ```
    mysql -u root -p
    ```
    按提示输入密码。
 3. 创建一个将被 Gitea 使用的数据库用户，并使用密码进行身份验证。以下示例中使用了 `'gitea'` 作为密码。请为您的实例使用一个安全密码。
    对于本地数据库：
    ```sql
    SET old_passwords=0;
    CREATE USER 'gitea' IDENTIFIED BY 'gitea';
    ```
    对于远程数据库：
    ```sql
    SET old_passwords=0;
    CREATE USER 'gitea'@'192.0.2.10' IDENTIFIED BY 'gitea';
    ```
    其中 `192.0.2.10` 是您的 Gitea 实例的 IP 地址。
    根据需要替换上述用户名和密码。
 4. 使用 UTF-8 字符集和排序规则创建数据库。确保使用 `**utf8mb4**` 字符集，而不是 `utf8`，因为前者支持 _Basic Multilingual Plane_ 之外的所有 Unicode 字符（包括表情符号）。排序规则根据您预期的内容选择。如果不确定，可以使用 `unicode_ci` 或 `general_ci`。
    ```sql
    CREATE DATABASE giteadb CHARACTER SET 'utf8mb4' COLLATE 'utf8mb4_unicode_ci';
    ```
    根据需要替换数据库名称。
 5. 将数据库上的所有权限授予上述创建的数据库用户。
    对于本地数据库：
    ```sql
    GRANT ALL PRIVILEGES ON giteadb.* TO 'gitea';
    FLUSH PRIVILEGES;
    ```
    对于远程数据库：
    ```sql
    GRANT ALL PRIVILEGES ON giteadb.* TO 'gitea'@'192.0.2.10';
    FLUSH PRIVILEGES;
    ```
 6. 通过 exit 退出数据库控制台。
 7. 在您的 Gitea 服务器上，测试与数据库的连接：
    ```
    mysql -u gitea -h 203.0.113.3 -p giteadb
    ```
    其中 `gitea` 是数据库用户名，`giteadb` 是数据库名称，`203.0.113.3` 是数据库实例的 IP 地址。对于本地数据库，省略 -h 选项。
    到此您应该能够连接到数据库了。
 ## PostgreSQL
 1. 对于远程数据库设置，通过编辑数据库实例上的 postgresql.conf 文件中的 listen_addresses 将 PostgreSQL 配置为监听您的 IP 地址：
    ```ini
    listen_addresses = 'localhost, 203.0.113.3'
    ```
 2. PostgreSQL 默认使用 `md5` 质询-响应加密方案进行密码身份验证。现在这个方案不再被认为是安全的。改用 SCRAM-SHA-256 方案，通过编辑数据库服务器上的` postgresql.conf` 配置文件：
    ```ini
    password_encryption = scram-sha-256
    ```
    重启 PostgreSQL 以应用该设置。
 3. 在数据库服务器上，以超级用户身份登录到数据库控制台：
    ```
    su -c "psql" - postgres
    ```
 4. 创建具有登录权限和密码的数据库用户（在 PostgreSQL 术语中称为角色）。请使用安全的、强密码，而不是下面的 `'gitea'`：
    ```sql
    CREATE ROLE gitea WITH LOGIN PASSWORD 'gitea';
    ```
    根据需要替换用户名和密码。
 5. 使用 UTF-8 字符集创建数据库，并由之前创建的数据库用户拥有。可以根据预期内容使用任何 `libc` 排序规则，使用 `LC_COLLATE` 和 `LC_CTYPE` 参数指定：
    ```sql
    CREATE DATABASE giteadb WITH OWNER gitea TEMPLATE template0 ENCODING UTF8 LC_COLLATE 'en_US.UTF-8' LC_CTYPE 'en_US.UTF-8';
    ```
    根据需要替换数据库名称。
 6. 通过将以下身份验证规则添加到 `pg_hba.conf`，允许数据库用户访问上面创建的数据库。
    对于本地数据库：
    ```ini
    local    giteadb    gitea    scram-sha-256
    ```
    对于远程数据库：
    ```ini
    host    giteadb    gitea    192.0.2.10/32    scram-sha-256
    ```
    根据您自己的数据库名称、用户和 Gitea 实例的 IP 地址进行替换。
    注意：`pg_hba.conf` 上的规则按顺序评估，也就是第一个匹配的规则将用于身份验证。您的 PostgreSQL 安装可能附带了适用于所有用户和数据库的通用身份验证规则。如果是这种情况，您可能需要将此处提供的规则放置在此类通用规则之上。
    重启 PostgreSQL 以应用新的身份验证规则。
 7. 在您的 Gitea 服务器上，测试与数据库的连接。
    对于本地数据库：
    ```
    psql -U gitea -d giteadb
    ```
    对于远程数据库：
    ```
    psql "postgres://gitea@203.0.113.3/giteadb"
    ```
    其中 `gitea` 是数据库用户，`giteadb` 是数据库名称，`203.0.113.3` 是您的数据库实例的 IP 地址。
    您应该会被提示输入数据库用户的密码，并连接到数据库。
 ## 使用 TLS 进行数据库连接
 如果 Gitea 和您的数据库实例之间的通信是通过私有网络进行的，或者如果 Gitea 和数据库运行在同一台服务器上，那么可以省略本节，因为 Gitea 和数据库实例之间的安全性不会受到严重威胁。但是，如果数据库实例位于公共网络上，请使用 TLS 对数据库连接进行加密，以防止第三方拦截流量数据。
 ### 先决条件
 - 您需要两个有效的 TLS 证书，一个用于数据库实例（数据库服务器），一个用于 Gitea 实例（数据库客户端）。两个证书都必须由受信任的 CA 签名。
 - 数据库证书必须在 `X509v3 Extended Key Usage` 扩展属性中包含 `TLS Web Server Authentication`，而客户端证书则需要在相应的属性中包含 `TLS Web Client Authentication`。
 - 在数据库服务器证书中，`Subject Alternative Name` 或 `Common Name` 条目之一必须是数据库实例的完全限定域名（FQDN）（例如 `db.example.com`）。在数据库客户端证书中，上述提到的条目之一必须包含 Gitea 将用于连接的数据库用户名。
 - 您需要将 Gitea 和数据库服务器的域名映射到它们各自的 IP 地址。可以为它们设置 DNS 记录，也可以在每个系统上的 `/etc/hosts`（Windows 中的 `%WINDIR%\System32\drivers\etc\hosts`）中添加本地映射。这样可以通过域名而不是 IP 地址进行数据库连接。有关详细信息，请参阅您系统的文档。
 ### PostgreSQL
 Gitea 使用的 PostgreSQL 驱动程序支持双向 TLS。在双向 TLS 中，数据库客户端和服务器通过将各自的证书发送给对方进行验证来相互认证。换句话说，服务器验证客户端证书，客户端验证服务器证书。
 1. 在数据库实例所在的服务器上，放置以下凭据：
    - `/path/to/postgresql.crt`: 数据库实例证书
    - `/path/to/postgresql.key`: 数据库实例私钥
    - `/path/to/root.crt`: 用于验证客户端证书的CA证书链
 2. 在 `postgresql.conf` 中添加以下选项：
    ```ini
    ssl = on
    ssl_ca_file = '/path/to/root.crt'
    ssl_cert_file = '/path/to/postgresql.crt'
    ssl_key_file = '/path/to/postgresql.key'
    ssl_min_protocol_version = 'TLSv1.2'
    ```
 3. 根据 PostgreSQL 的要求，调整凭据的所有权和权限：
    ```
    chown postgres:postgres /path/to/root.crt /path/to/postgresql.crt /path/to/postgresql.key
    chmod 0600 /path/to/root.crt /path/to/postgresql.crt /path/to/postgresql.key
    ```
 4. 编辑 `pg_hba.conf` 规则，仅允许 Gitea 数据库用户通过SSL连接，并要求客户端证书验证。
    对于PostgreSQL 12：
    ```ini
    hostssl    giteadb    gitea    192.0.2.10/32    scram-sha-256    clientcert=verify-full
    ```
    对于PostgreSQL 11及更早版本：
    ```ini
    hostssl    giteadb    gitea    192.0.2.10/32    scram-sha-256    clientcert=1
    ```
    根据需要替换数据库名称、用户和 Gitea 实例的 IP 地址。
 5. 重新启动 PostgreSQL 以应用上述配置。
 6. 在运行 Gitea 实例的服务器上，将以下凭据放置在运行 Gitea 的用户的主目录下（例如 `git`）：
    - `~/.postgresql/postgresql.crt`: 数据库客户端证书
    - `~/.postgresql/postgresql.key`: 数据库客户端私钥
    - `~/.postgresql/root.crt`: 用于验证服务器证书的CA证书链
    注意：上述文件名在 PostgreSQL 中是硬编码的，无法更改。
 7. 根据需要调整凭据、所有权和权限：
    ```
    chown git:git ~/.postgresql/postgresql.crt ~/.postgresql/postgresql.key ~/.postgresql/root.crt
    chown 0600 ~/.postgresql/postgresql.crt ~/.postgresql/postgresql.key ~/.postgresql/root.crt
    ```
 8. 测试与数据库的连接：
    ```
    psql "postgres://gitea@example.db/giteadb?sslmode=verify-full"
    ```
    您将被提示输入数据库用户的密码，然后连接到数据库。
 ### MySQL
 虽然 Gitea 使用的MySQL驱动程序也支持双向 TLS，但目前 Gitea 仅支持单向 TLS。有关详细信息，请参见工单＃10828。
 在单向TLS中，数据库客户端在连接握手期间验证服务器发送的证书，而服务器则假定连接的客户端是合法的，因为不进行客户端证书验证。
 1. 在数据库实例上放置以下凭据：
    - `/path/to/mysql.crt`: 数据库实例证书
    - `/path/to/mysql.key`: 数据库实例密钥
    - `/path/to/ca.crt`: CA证书链。在单向TLS中不使用此文件，但用于验证双向TLS中的客户端证书。
 2. 将以下选项添加到 `my.cnf`：
    ```ini
    [mysqld]
    ssl-ca = /path/to/ca.crt
    ssl-cert = /path/to/mysql.crt
    ssl-key = /path/to/mysql.key
    tls-version = TLSv1.2,TLSv1.3
    ```
 3. 调整凭据的所有权和权限：
    ```
    chown mysql:mysql /path/to/ca.crt /path/to/mysql.crt /path/to/mysql.key
    chmod 0600 /path/to/ca.crt /path/to/mysql.crt /path/to/mysql.key
    ```
 4. 重新启动MySQL以应用设置。
 5. Gitea 的数据库用户可能已经创建过，但只会对运行 Gitea 的服务器的 IP 地址进行身份验证。要对其域名进行身份验证，请重新创建用户，并设置其需要通过 TLS 连接到数据库：
    ```sql
    DROP USER 'gitea'@'192.0.2.10';
    CREATE USER 'gitea'@'example.gitea' IDENTIFIED BY 'gitea' REQUIRE SSL;
    GRANT ALL PRIVILEGES ON giteadb.* TO 'gitea'@'example.gitea';
    FLUSH PRIVILEGES;
    ```
    根据需要替换数据库用户名、密码和 Gitea 实例域名。
 6. 确保用于验证数据库服务器证书的CA证书链位于数据库和 Gitea 服务器的系统证书存储中。请参考系统文档中有关将 CA 证书添加到证书存储的说明。
 7. 在运行Gitea的服务器上，测试与数据库的连接：
    ```
    mysql -u gitea -h example.db -p --ssl
    ```
    至此应该成功连接到数据库了。
--- a/docs/content/doc/installation/from-binary.zh-cn.md
+++ b/docs/content/doc/installation/from-binary.zh-cn.md
@ -1,6 +1,6 @@
 ---
 date: "2016-12-01T16:00:00+02:00"
-title: "从二进制安装"
+title: "使用二进制文件安装"
 slug: "install-from-binary"
 weight: 15
 toc: false
@ -8,12 +8,12 @@ draft: false
 menu:
  sidebar:
    parent: "installation"
-    name: "从二进制安装"
+    name: "使用二进制文件安装"
    weight: 15
    identifier: "install-from-binary"
 ---
-# 从二进制安装
+# 使用二进制文件安装
 所有打包的二进制程序均包含 SQLite，MySQL 和 PostgreSQL 的数据库连接支持，同时网站的静态资源均已嵌入到可执行程序中，这一点和曾经的 Gogs 有所不同。
--- a/docs/content/doc/installation/from-source.zh-cn.md
+++ b/docs/content/doc/installation/from-source.zh-cn.md
@ -1,6 +1,6 @@
 ---
 date: "2016-12-01T16:00:00+02:00"
-title: "从源代码安装"
+title: "使用源代码安装"
 slug: "install-from-source"
 weight: 30
 toc: false
@ -8,12 +8,12 @@ draft: false
 menu:
  sidebar:
    parent: "installation"
-    name: "从源代码安装"
+    name: "使用源代码安装"
    weight: 30
    identifier: "install-from-source"
 ---
-# 从源代码安装
+# 使用源代码安装
 首先你需要安装Golang，关于Golang的安装，参见[官方文档](https://golang.google.cn/doc/install)。
--- a/docs/content/doc/installation/on-cloud-provider.zh-cn.md
+++ b/docs/content/doc/installation/on-cloud-provider.zh-cn.md
@ -0,0 +1,57 @@
 ---
 date: "2016-12-01T16:00:00+02:00"
 title: "在云服务器中安装 Gitea"
 slug: "install-on-cloud-provider"
 weight: 90
 toc: false
 draft: false
 aliases:
  - /zh-cn/install-on-cloud-provider
 menu:
  sidebar:
    parent: "installation"
    name: "在云服务器中安装 Gitea"
    weight: 90
    identifier: "install-on-cloud-provider"
 ---
 # 在云服务器上安装 Gitea
 **Table of Contents**
 {{< toc >}}
 ## Cloudron
 Gitea 可以在 [Cloudron](https://cloudron.io) 上进行一键安装。
 Cloudron 使得在您的服务器上运行 Gitea，并保持其更新和安全变得简单。
 [![Install](/cloudron.svg)](https://cloudron.io/button.html?app=io.gitea.cloudronapp)
 Gitea软件包的维护地址在[这里](https://git.cloudron.io/cloudron/gitea-app).
 这里有一个[demo 实例](https://my.demo.cloudron.io) (用户名: cloudron 密码: cloudron) 您可以在其中尝试运行Gitea。
 ## Vultr
 Gitea 可以在 [Vultr](https://www.vultr.com) 的市场中被找到。
 要将 Gitea 部署到 Vultr，请参考 [Vultr Marketplace](https://www.vultr.com/marketplace/apps/gitea).
 ## DigitalOcean
 [DigitalOcean](https://www.digitalocean.com) 将 Gitea 作为其市场中的一个 droplet。
 要将 Gitea 部署到 DigitalOcean, 请参考 [DigitalOcean Marketplace](https://marketplace.digitalocean.com/apps/gitea).
 ## Linode
 [Linode](https://www.linode.com/) 将 Gitea 作为其市场中的一个应用程序.
 要将 Gitea 部署到 Linode, 请参考 [Linode Marketplace](https://www.linode.com/marketplace/apps/linode/gitea/).
 ## alwaysdata
 [alwaysdata](https://www.alwaysdata.com/) 将 Gitea 作为其市场中的一个 droplet.
 要将 Gitea 部署到 alwaysdata, 请参考 [alwaysdata Marketplace](https://www.alwaysdata.com/en/marketplace/gitea/).
--- a/docs/content/doc/installation/on-kubernetes.zh-cn.md
+++ b/docs/content/doc/installation/on-kubernetes.zh-cn.md
@ -1,6 +1,6 @@
 ---
 date: "2020-03-19T19:27:00+02:00"
-title: "在 Kubernetes 安装 Gitea"
+title: "在 Kubernetes 中安装 Gitea"
 slug: "install-on-kubernetes"
 weight: 80
 toc: false
@ -8,7 +8,7 @@ draft: false
 menu:
  sidebar:
    parent: "installation"
-    name: "Kubernetes"
+    name: "在 Kubernetes 中安装 Gitea"
    weight: 80
    identifier: "install-on-kubernetes"
 ---
--- a/docs/content/doc/installation/with-docker-rootless.zh-cn.md
+++ b/docs/content/doc/installation/with-docker-rootless.zh-cn.md
@ -0,0 +1,332 @@
 ---
 date: "2020-02-09T20:00:00+02:00"
 title: "使用 Docker 安装 (rootless)"
 slug: "install-with-docker-rootless"
 weight: 60
 toc: false
 draft: false
 aliases:
  - /zh-cn/install-with-docker-rootless
 menu:
  sidebar:
    parent: "installation"
    name: "使用 Docker 安装 (rootless)"
    weight: 60
    identifier: "install-with-docker-rootless"
 ---
 # 使用 Docker 安装
 Gitea 在其 Docker Hub 组织中提供自动更新的 Docker 镜像。您可以始终使用最新的稳定标签，或使用其他处理 Docker 镜像更新的服务。
 rootless 镜像使用 Gitea 内部 SSH 功能来提供 Git 协议，但不支持 OpenSSH。
 本参考设置指南将用户引导通过基于 `docker-compose` 的设置。但是，`docker-compose` 的安装超出了本文档的范围。要安装`docker-compose` 本身， 请按照官方的 [安装说明](https://docs.docker.com/compose/install/)进行操作。
 ## 基础设置
 最简单的设置只需创建一个卷和一个网络，并将 `gitea/gitea:latest-rootless` 镜像作为服务启动。由于没有可用的数据库，可以使用 SQLite3 来初始化一个。
 创建一个名为 `data` 和 `config`:
 ```sh
 mkdir -p gitea/{data,config}
 cd gitea
 touch docker-compose.yml
 ```
 然后将以下内容粘贴到名为 `docker-compose.yml` 的文件中：
 ```yaml
 version: "2"
 services:
  server:
    image: gitea/gitea:{{< version >}}-rootless
    restart: always
    volumes:
      - ./data:/var/lib/gitea
      - ./config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "2222:2222"
 ```
 请注意，卷应由在配置文件中指定的UID/GID的用户/组所有。默认情况下，Docker中的Gitea将使用uid:1000 gid:1000。如果需要，您可以使用以下命令设置这些文件夹的所有权：
 ```sh
 sudo chown 1000:1000 config/ data/
 ```
 > 如果未为卷设置正确的权限，容器可能无法启动。
 对于稳定版本，您可以使用 `:latest-rootless`、`:1-rootless`，或指定特定的版本，如: `{{< version >}}-rootless`。如果您想使用最新的开发版本，则可以使用 `:dev-rootless` 标签。如果您想运行发布分支的最新提交，可以使用 `:1.x-dev-rootless` 标签，其中 x是 Gitea 的次要版本号（例如:`1.16-dev-rootless`）。
 ## 自定义端口
 要将集成的SSH和Web服务器绑定到不同的端口，请调整端口部分。通常只需更改主机端口并保持容器内的端口不变。
 ```diff
 version: "2"
 services:
  server:
    image: gitea/gitea:{{< version >}}-rootless
    restart: always
    volumes:
      - ./data:/var/lib/gitea
      - ./config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
 -      - "3000:3000"
 -      - "2222:2222"
 +      - "80:3000"
 +      - "22:2222"
 ```
 ## MySQL 数据库
 要将 Gitea 与 MySQL 数据库结合使用，请对上面创建的 `docker-compose.yml` 文件进行以下更改。
 ```diff
 version: "2"
 services:
  server:
    image: gitea/gitea:{{< version >}}-rootless
 +    environment:
 +      - GITEA__database__DB_TYPE=mysql
 +      - GITEA__database__HOST=db:3306
 +      - GITEA__database__NAME=gitea
 +      - GITEA__database__USER=gitea
 +      - GITEA__database__PASSWD=gitea
    restart: always
    volumes:
      - ./data:/var/lib/gitea
      - ./config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"
 +    depends_on:
 +      - db
 +
 +  db:
 +    image: mysql:8
 +    restart: always
 +    environment:
 +      - MYSQL_ROOT_PASSWORD=gitea
 +      - MYSQL_USER=gitea
 +      - MYSQL_PASSWORD=gitea
 +      - MYSQL_DATABASE=gitea
 +    volumes:
 +      - ./mysql:/var/lib/mysql
 ```
 ## PostgreSQL 数据库
 要将 Gitea 与 PostgreSQL 数据库结合使用，请对上面创建的 `docker-compose.yml` 文件进行以下更改。
 ```diff
 version: "2"
 services:
  server:
    image: gitea/gitea:{{< version >}}-rootless
    environment:
 +      - GITEA__database__DB_TYPE=postgres
 +      - GITEA__database__HOST=db:5432
 +      - GITEA__database__NAME=gitea
 +      - GITEA__database__USER=gitea
 +      - GITEA__database__PASSWD=gitea
    restart: always
    volumes:
      - ./data:/var/lib/gitea
      - ./config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "2222:2222"
 +    depends_on:
 +      - db
 +
 +  db:
 +    image: postgres:14
 +    restart: always
 +    environment:
 +      - POSTGRES_USER=gitea
 +      - POSTGRES_PASSWORD=gitea
 +      - POSTGRES_DB=gitea
 +    volumes:
 +      - ./postgres:/var/lib/postgresql/data
 ```
 ## 命名卷 (Named Volumes)
 要使用命名卷 (Named Volumes) 而不是主机卷 (Host Volumes)，请在 `docker-compose.yml` 配置中定义和使用命名卷。这样的更改将自动创建所需的卷。您不需要担心权限问题，Docker 会自动处理。
 ```diff
 version: "2"
 +volumes:
 +  gitea-data:
 +    driver: local
 +  gitea-config:
 +    driver: local
 +
 services:
  server:
    image: gitea/gitea:{{< version >}}-rootless
    restart: always
    volumes:
 -      - ./data:/var/lib/gitea
 +      - gitea-data:/var/lib/gitea
 -      - ./config:/etc/gitea
 +      - gitea-config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "2222:2222"
 ```
 MySQL 或 PostgreSQL 容器需要单独创建。
 ## 自定义用户
 你可以选择使用自定义用户 (遵循 --user 标志定义 https://docs.docker.com/engine/reference/run/#user)。
 例如，要克隆主机用户 `git` 的定义，请使用命令 `id -u git` 并将其添加到 `docker-compose.yml` 文件中：
 请确用户对保挂载的文件夹具有写权限。
 ```diff
 version: "2"
 services:
  server:
    image: gitea/gitea:{{< version >}}-rootless
    restart: always
 +    user: 1001
    volumes:
      - ./data:/var/lib/gitea
      - ./config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "2222:2222"
 ```
 ## 启动
 要启动基于 `docker-compose` 的这个设置，请执行 `docker-compose up -d`，以在后台启动 Gitea。使用 `docker-compose ps` 命令可以查看 Gitea 是否正确启动。可以使用 `docker-compose logs` 命令查看日志。
 要关闭设置，请执行 `docker-compose down` 命令。这将停止和终止容器，但卷仍将存在。
 注意：如果在 HTTP 上使用的是非 3000 端口，请将 app.ini 更改为匹配 `LOCAL_ROOT_URL = http://localhost:3000/`。
 ## 安装
 在通过 `docker-compose` 启动 Docker 设置后，可以使用喜爱的浏览器访问 Gitea，完成安装过程。访问 `http://<服务器-IP>:3000` 并按照安装向导进行操作。如果数据库是使用上述文档中的 `docker-compose` 设置启动的，请注意必须使用 `db` 作为数据库主机名。
 # 自定义
 自定义文件的位置位于 `/var/lib/gitea/custom` 目录中，可以在这里找到有关自定义的文件说明。如果使用主机卷（host volumes），很容易访问这些文件；如果使用命名卷（named volumes），则可以通过另一个容器或直接访问 `/var/lib/docker/volumes/gitea_gitea/_/var_lib_gitea` 来进行访问。在安装后，配置文件将保存在 `/etc/gitea/app.ini` 中。
 # 升级
 :exclamation::exclamation: **确保您已将数据卷迁移到 Docker 容器之外的其他位置** :exclamation::exclamation:
 要将安装升级到最新版本，请按照以下步骤操作：
 ```
 # 如果在 docker-compose.yml 中指定了版本，请编辑该文件以更新版本
 # 拉取新的镜像
 docker-compose pull
 # 启动一个新的容器，自动移除旧的容器
 docker-compose up -d
 ```
 # 从标准镜像升级
 - 备份您的设置
 - 将卷挂载点从 `/data` 更改为 `/var/lib/gitea`
 - 如果使用了自定义的 `app.ini`，请将其移动到新的挂载到 `/etc/gitea` 的卷中
 - 将卷中的文件夹（gitea）重命名为 custom
 - 如果需要，编辑 `app.ini`
  - 设置 `START_SSH_SERVER = true`
 - 使用镜像 `gitea/gitea:{{< version >}}-rootless`
 ## 使用环境变量管理部署
 除了上述的环境变量外，`app.ini` 中的任何设置都可以通过形式为 `GITEA__SECTION_NAME__KEY_NAME` 的环境变量进行设置或覆盖。这些设置在每次 Docker 容器启动时都会生效。完整信息请参考[这里](https://github.com/go-gitea/gitea/tree/main/contrib/environment-to-ini).
 这些环境变量可以在 `docker-compose.yml` 中传递给 Docker 容器。以下示例将启用 SMTP 邮件服务器，如果主机上设置了所需的环境变量 GITEA__mailer__FROM、GITEA__mailer__HOST、GITEA__mailer__PASSWD，或者在与 `docker-compose.yml` 相同目录中的 `.env` 文件中设置了这些环境变量：
 ```bash
 ...
 services:
  server:
    environment:
      - GITEA__mailer__ENABLED=true
      - GITEA__mailer__FROM=${GITEA__mailer__FROM:?GITEA__mailer__FROM not set}
      - GITEA__mailer__MAILER_TYPE=smtp
      - GITEA__mailer__HOST=${GITEA__mailer__HOST:?GITEA__mailer__HOST not set}
      - GITEA__mailer__IS_TLS_ENABLED=true
      - GITEA__mailer__USER=${GITEA__mailer__USER:-apikey}
      - GITEA__mailer__PASSWD="""${GITEA__mailer__PASSWD:?GITEA__mailer__PASSWD not set}"""
 ```
 要设置所需的 TOKEN 和 SECRET 值，可以使用 Gitea 的内置[生成使用函数](https://docs.gitea.io/en-us/command-line/#generate).
 # SSH 容器透传
 由于 SSH 在容器内运行，如果需要 SSH 支持，需要将 SSH 从主机透传到容器。一种选择是在容器内运行 SSH，并使用非标准端口（或将主机端口移动到非标准端口）。另一种可能更直接的选择是将主机上的 SSH 命令转发到容器。下面解释了这种设置。
 本指南假设您已在主机上创建了一个名为 `git` 的用户，并具有运行 `docker exec` 的权限，并且 Gitea 容器的名称为 `gitea`。您需要修改该用户的 shell，以将命令转发到容器内的 `sh` 可执行文件，使用 `docker exec`。
 首先，在主机上创建文件 `/usr/local/bin/gitea-shell`，并填入以下内容：
 ```bash
 #!/bin/sh
 /usr/bin/docker exec -i --env SSH_ORIGINAL_COMMAND="$SSH_ORIGINAL_COMMAND" gitea sh "$@"
 ```
 注意上述 docker 命令中的 `gitea` 是容器的名称。如果您的容器名称不同，请记得更改。
 还应确保正确设置了 shell 包装器的权限：
 ```bash
 sudo chmod +x /usr/local/bin/gitea-shell
 ```
 一旦包装器就位，您可以将其设置为 `git` 用户的 shell：
 ```bash
 sudo usermod -s /usr/local/bin/gitea-shell git
 ```
 现在，所有的 SSH 命令都会被转发到容器，您需要在主机上设置 SSH 认证。这可以通过利用 [SSH AuthorizedKeysCommand](https://docs.gitea.io/en-us/command-line/#keys) 来匹配 Gitea 接受的密钥。在主机的 `/etc/ssh/sshd_config` 文件中添加以下代码块：
 ```bash
 Match User git
  AuthorizedKeysCommandUser git
  AuthorizedKeysCommand /usr/bin/docker exec -i gitea /usr/local/bin/gitea keys -c /etc/gitea/app.ini -e git -u %u -t %t -k %k
 ```
 （从 1.16.0 开始，您将不需要设置 `-c /etc/gitea/app.ini` 选项。）
 剩下的就是重新启动 SSH 服务器：
 ```bash
 sudo systemctl restart sshd
 ```
 **注意**
 这实际上并没有使用 Docker 的 SSH，而是仅仅使用了围绕它的命令。
 从理论上讲，您可以不运行内部的 SSH 服务器。
--- a/docs/content/doc/packages/alpine.zh-cn.md
+++ b/docs/content/doc/packages/alpine.zh-cn.md
@ -0,0 +1,133 @@
 ---
 date: "2023-03-25T00:00:00+00:00"
 title: "Alpine 软件包注册表"
 slug: "alpine"
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Alpine"
    weight: 4
    identifier: "alpine"
 ---
 # Alpine 软件包注册表
 在您的用户或组织中发布 [Alpine](https://pkgs.alpinelinux.org/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 Alpine 注册表，您需要使用像 curl 这样的 HTTP 客户端来上传包，并使用像 apk 这样的包管理器来消费包。
 以下示例使用 `apk`。
 ## 配置软件包注册表
 要注册 Alpine 注册表，请将 URL 添加到已知的 apk 源列表中 (`/etc/apk/repositories`):
 ```
 https://gitea.example.com/api/packages/{owner}/alpine/<branch>/<repository>
 ```
 | 占位符       | 描述           |
 | ------------ | -------------- |
 | `owner`      | 软件包所有者   |
 | `branch`     | 要使用的分支名 |
 | `repository` | 要使用的仓库名 |
 如果注册表是私有的，请在 URL 中提供凭据。您可以使用密码或[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}}):
 ```
 https://{username}:{your_password_or_token}@gitea.example.com/api/packages/{owner}/alpine/<branch>/<repository>
 ```
 Alpine 注册表文件使用 RSA 密钥进行签名，apk 必须知道该密钥。下载公钥并将其存储在 `/etc/apk/keys/` 目录中：
 ```shell
 curl -JO https://gitea.example.com/api/packages/{owner}/alpine/key
 ```
 之后，更新本地软件包索引：
 ```shell
 apk update
 ```
 ## 发布软件包
 要发布一个 Alpine 包（`*.apk`），请执行带有包内容的 HTTP `PUT` 操作，将其放在请求体中。
 ```
 PUT https://gitea.example.com/api/packages/{owner}/alpine/{branch}/{repository}
 ```
 | 参数         | 描述                                                                                                |
 | ------------ | --------------------------------------------------------------------------------------------------- |
 | `owner`      | 包的所有者。                                                                                        |
 | `branch`     | 分支可以与操作系统的发行版本匹配，例如：v3.17。                                                     |
 | `repository` | 仓库可以用于[分组包](https://wiki.alpinelinux.org/wiki/Repositories) 或者只是 `main` 或类似的名称。 |
 使用 HTTP 基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/file.apk \
     https://gitea.example.com/api/packages/testuser/alpine/v3.17/main
 ```
 如果您使用的是双重身份验证或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})代替密码。
 您不能将具有相同名称的文件两次发布到一个包中。您必须首先删除现有的包文件。
 服务器将以以下的 HTTP 状态码响应：
 | HTTP 状态码       | 含义                                       |
 | ----------------- | ------------------------------------------ |
 | `201 Created`     | 软件包已发布。                             |
 | `400 Bad Request` | 软件包的名称、版本、分支、仓库或架构无效。 |
 | `409 Conflict`    | 具有相同参数组合的包文件已存在于软件包中。 |
 ## 删除软件包
 要删除 Alpine 包，执行 HTTP 的 DELETE 操作。如果没有文件，这将同时删除包版本。
 ```
 DELETE https://gitea.example.com/api/packages/{owner}/alpine/{branch}/{repository}/{architecture}/{filename}
 ```
 | 参数           | 描述           |
 | -------------- | -------------- |
 | `owner`        | 软件包的所有者 |
 | `branch`       | 要使用的分支名 |
 | `repository`   | 要使用的仓库名 |
 | `architecture` | 软件包的架构   |
 | `filename`     | 要删除的文件名 |
 使用 HTTP 基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_token_or_password -X DELETE \
     https://gitea.example.com/api/packages/testuser/alpine/v3.17/main/test-package-1.0.0.apk
 ```
 服务器将以以下的 HTTP 状态码响应：
 | HTTP 状态码      | 含义               |
 | ---------------- | ------------------ |
 | `204 No Content` | 成功               |
 | `404 Not Found`  | 未找到软件包或文件 |
 ## 安装软件包
 要从 Alpine 注册表安装软件包，请执行以下命令：
 ```shell
 # use latest version
 apk add {package_name}
 # use specific version
 apk add {package_name}={package_version}
 ```
--- a/docs/content/doc/packages/cargo.zh-cn.md
+++ b/docs/content/doc/packages/cargo.zh-cn.md
@ -0,0 +1,110 @@
 ---
 date: "2022-11-20T00:00:00+00:00"
 title: "Cargo 软件包注册表"
 slug: "cargo"
 weight: 5
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Cargo"
    weight: 5
    identifier: "cargo"
 ---
 # Cargo 软件包注册表
 为您的用户或组织发布 [Cargo](https://doc.rust-lang.org/stable/cargo/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 若要使用 Cargo 软件包注册表, 您需要安装 [Rust 和 Cargo](https://www.rust-lang.org/tools/install).
 Cargo 将可用软件包的信息存储在一个存储在 git 仓库中的软件包索引中。
 这个仓库是与注册表交互所必需的。
 下面的部分将介绍如何创建它。
 ## 索引仓库
 Cargo 将可用软件包的信息存储在一个存储在 git 仓库中的软件包索引中。
 在 Gitea 中，这个仓库有一个特殊的名称叫做 `_cargo-index`。
 在上传软件包之后，它的元数据会自动写入索引中。
 不应手动修改这个注册表的内容。
 用户或组织软件包设置页面允许创建这个索引仓库以及配置文件。
 如果需要，此操作将重写配置文件。
 例如，如果 Gitea 实例的域名已更改，这将非常有用。
 如果存储在 Gitea 中的软件包与索引注册表中的信息不同步，设置页面允许重建这个索引注册表。
 这个操作将遍历注册表中的所有软件包，并将它们的信息写入索引中。
 如果有很多软件包，这个过程可能需要一些时间。
 ## 配置软件包注册表
 要注册这个软件包注册表，必须更新 Cargo 的配置。
 将以下文本添加到位于当前用户主目录中的配置文件中（例如 `~/.cargo/config.toml`）：
 ```
 [registry]
 default = "gitea"
 [registries.gitea]
 index = "https://gitea.example.com/{owner}/_cargo-index.git"
 [net]
 git-fetch-with-cli = true
 ```
 | 参数    | 描述             |
 | ------- | ---------------- |
 | `owner` | 软件包的所有者。 |
 如果这个注册表是私有的或者您想要发布新的软件包，您必须配置您的凭据。
 将凭据部分添加到位于当前用户主目录中的凭据文件中（例如 `~/.cargo/credentials.toml`）：
 ```
 [registries.gitea]
 token = "Bearer {token}"
 ```
 | 参数    | 描述                                                                                  |
 | ------- | ------------------------------------------------------------------------------------- |
 | `token` | 您的[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}}) |
 ## 发布软件包
 在项目中运行以下命令来发布软件包：
 ```shell
 cargo publish
 ```
 如果已经存在同名和版本的软件包，您将无法发布新的软件包。您必须先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表安装软件包，请执行以下命令：
 ```shell
 cargo add {package_name}
 ```
 | 参数           | 描述         |
 | -------------- | ------------ |
 | `package_name` | 软件包名称。 |
 ## 支持的命令
 ```
 cargo publish
 cargo add
 cargo install
 cargo yank
 cargo unyank
 cargo search
 ```
--- a/docs/content/doc/packages/chef.zh-cn.md
+++ b/docs/content/doc/packages/chef.zh-cn.md
@ -0,0 +1,97 @@
 ---
 date: "2023-01-20T00:00:00+00:00"
 title: "Chef 软件包注册表"
 slug: "chef"
 weight: 5
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Chef"
    weight: 5
    identifier: "chef"
 ---
 # Chef Package Registry
 为您的用户或组织发布 [Chef](https://chef.io/) cookbooks。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 Chef 软件包注册表，您需要使用 [`knife`](https://docs.chef.io/workstation/knife/).
 ## 认证
 Chef 软件包注册表不使用用户名和密码进行身份验证，而是使用私钥和公钥对请求进行签名。
 请访问软件包所有者设置页面以创建必要的密钥对。
 只有公钥存储在Gitea中。如果您丢失了私钥的访问权限，您必须重新生成密钥对。
 [配置 `knife`](https://docs.chef.io/workstation/knife_setup/)，使用下载的私钥，并将 Gitea 用户名设置为 `client_name`。
 ## 配置软件包注册表
 要将 [`knife` 配置](https://docs.chef.io/workstation/knife_setup/)为使用 Gitea 软件包注册表，请将 URL 添加到 `~/.chef/config.rb` 文件中。
 ```
 knife[:supermarket_site] = 'https://gitea.example.com/api/packages/{owner}/chef'
 ```
 | 参数    | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 ## 发布软件包
 若要发布 Chef 软件包，请执行以下命令：
 ```shell
 knife supermarket share {package_name}
 ```
 | 参数           | 描述       |
 | -------------- | ---------- |
 | `package_name` | 软件包名称 |
 如果已经存在同名和版本的软件包，则无法发布新的软件包。您必须先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表中安装软件包，请执行以下命令：
 ```shell
 knife supermarket install {package_name}
 ```
 您可以指定软件包的版本，这是可选的：
 ```shell
 knife supermarket install {package_name} {package_version}
 ```
 | 参数              | 描述       |
 | ----------------- | ---------- |
 | `package_name`    | 软件包名称 |
 | `package_version` | 软件包版本 |
 ## 删除软件包
 如果您想要从注册表中删除软件包，请执行以下命令：
 ```shell
 knife supermarket unshare {package_name}
 ```
 可选地，您可以指定软件包的版本：
 ```shell
 knife supermarket unshare {package_name}/versions/{package_version}
 ```
 | 参数              | 描述       |
 | ----------------- | ---------- |
 | `package_name`    | 软件包名称 |
 | `package_version` | 软件包版本 |
--- a/docs/content/doc/packages/composer.zh-cn.md
+++ b/docs/content/doc/packages/composer.zh-cn.md
@ -0,0 +1,123 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "Composer 软件包注册表"
 slug: "composer"
 weight: 10
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Composer"
    weight: 10
    identifier: "composer"
 ---
 # Composer 软件包注册表
 为您的用户或组织发布 [Composer](https://getcomposer.org/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 Composer 软件包注册表，您可以使用 [Composer](https://getcomposer.org/download/) 消费，并使用类似 `curl` 的 HTTP 上传客户端发布软件包。
 ## 发布软件包
 要发布 Composer 软件包，请执行 HTTP `PUT` 操作，将软件包内容放入请求体中。
 软件包内容必须是包含 `composer.json` 文件的压缩 PHP 项目。
 如果已经存在同名和版本的软件包，则无法发布新的软件包。您必须先删除现有的软件包。
 ```
 PUT https://gitea.example.com/api/packages/{owner}/composer
 ```
 | 参数    | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 如果 `composer.json` 文件不包含 `version` 属性，您必须将其作为查询参数提供：
 ```
 PUT https://gitea.example.com/api/packages/{owner}/composer?version={x.y.z}
 ```
 使用 HTTP 基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/project.zip \
     https://gitea.example.com/api/packages/testuser/composer
 ```
 或者将软件包版本指定为查询参数：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/project.zip \
     https://gitea.example.com/api/packages/testuser/composer?version=1.0.3
 ```
 如果您使用 2FA 或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})替代密码。
 服务器将以以下 HTTP 状态码响应。
 | HTTP 状态码       | 含义                                                        |
 | ----------------- | ----------------------------------------------------------- |
 | `201 Created`     | 软件包已发布                                                |
 | `400 Bad Request` | 软件包名称和/或版本无效，或具有相同名称和版本的软件包已存在 |
 ## 配置软件包注册表
 要注册软件包注册表，您需要将其添加到 Composer 的 `config.json` 文件中（通常可以在 `<user-home-dir>/.composer/config.json` 中找到）：
 ```json
 {
  "repositories": [{
      "type": "composer",
      "url": "https://gitea.example.com/api/packages/{owner}/composer"
   }
  ]
 }
 ```
 要使用凭据访问软件包注册表，您必须在 `auth.json` 文件中指定它们，如下所示：
 ```json
 {
  "http-basic": {
    "gitea.example.com": {
      "username": "{username}",
      "password": "{password}"
    }
  }
 }
 ```
 | 参数       | 描述                        |
 | ---------- | --------------------------- |
 | `owner`    | 软件包的所有者              |
 | `username` | 您的 Gitea 用户名           |
 | `password` | 您的Gitea密码或个人访问令牌 |
 ## 安装软件包
 要从软件包注册表中安装软件包，请执行以下命令：
 ```shell
 composer require {package_name}
 ```
 您可以指定软件包的版本，这是可选的：
 ```shell
 composer require {package_name}:{package_version}
 ```
 | 参数              | 描述       |
 | ----------------- | ---------- |
 | `package_name`    | 软件包名称 |
 | `package_version` | 软件包版本 |
--- a/docs/content/doc/packages/conan.zh-cn.md
+++ b/docs/content/doc/packages/conan.zh-cn.md
@ -0,0 +1,102 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "Conan 软件包注册表"
 slug: "conan"
 weight: 20
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Conan"
    weight: 20
    identifier: "conan"
 ---
 # Conan 软件包注册表
 为您的用户或组织发布 [Conan](https://conan.io/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 [conan](https://conan.io/downloads.html) 软件包注册表，您需要使用 conan 命令行工具来消费和发布软件包。
 ## 配置软件包注册表
 要注册软件包注册表，您需要配置一个新的 Conan remote：
 ```shell
 conan remote add {remote} https://gitea.example.com/api/packages/{owner}/conan
 conan user --remote {remote} --password {password} {username}
 ```
 | 参数       | 描述                                                                                                                                        |
 | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
 | `remote`   | 远程名称。                                                                                                                                  |
 | `username` | 您的 Gitea 用户名。                                                                                                                         |
 | `password` | 您的 Gitea 密码。如果您使用 2FA 或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})替代密码。 |
 | `owner`    | 软件包的所有者。                                                                                                                            |
 例如:
 ```shell
 conan remote add gitea https://gitea.example.com/api/packages/testuser/conan
 conan user --remote gitea --password password123 testuser
 ```
 ## 发布软件包
 通过运行以下命令发布 Conan 软件包：
 ```shell
 conan upload --remote={remote} {recipe}
 ```
 | 参数     | 描述            |
 | -------- | --------------- |
 | `remote` | 远程名称        |
 | `recipe` | 要上传的 recipe |
 For example:
 ```shell
 conan upload --remote=gitea ConanPackage/1.2@gitea/final
 ```
 Gitea Conan 软件包注册表支持完整的[版本修订](https://docs.conan.io/en/latest/versioning/revisions.html)。
 ## 安装软件包
 要从软件包注册表中安装Conan软件包，请执行以下命令：
 ```shell
 conan install --remote={remote} {recipe}
 ```
 | 参数     | 描述            |
 | -------- | --------------- |
 | `remote` | 远程名称        |
 | `recipe` | 要下载的 recipe |
 例如：
 ```shell
 conan install --remote=gitea ConanPackage/1.2@gitea/final
 ```
 ## 支持的命令
 ```
 conan install
 conan get
 conan info
 conan search
 conan upload
 conan user
 conan download
 conan remove
 ```
--- a/docs/content/doc/packages/conda.zh-cn.md
+++ b/docs/content/doc/packages/conda.zh-cn.md
@ -0,0 +1,86 @@
 ---
 date: "2022-12-28T00:00:00+00:00"
 title: "Conda 软件包注册表"
 slug: "conda"
 weight: 25
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Conda"
    weight: 25
    identifier: "conda"
 ---
 # Conda 软件包注册表
 为您的用户或组织发布 [Conda](https://docs.conda.io/en/latest/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 Conda 软件包注册表，您需要使用 [conda](https://docs.conda.io/projects/conda/en/stable/user-guide/install/index.html) 命令行工具。
 ## 配置软件包注册表
 要注册软件包注册表并提供凭据，请编辑您的 `.condarc` 文件：
 ```yaml
 channel_alias: https://gitea.example.com/api/packages/{owner}/conda
 channels:
  - https://gitea.example.com/api/packages/{owner}/conda
 default_channels:
  - https://gitea.example.com/api/packages/{owner}/conda
 ```
 | 占位符  | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 有关各个设置的解释，请参阅[官方文档](https://conda.io/projects/conda/en/latest/user-guide/configuration/use-condarc.html)。
 如果需要提供凭据，可以将它们作为通道 URL 的一部分嵌入（`https://user:password@gitea.example.com/...`）。
 ## 发布软件包
 要发布一个软件包，请执行一个HTTP `PUT`操作，请求正文中包含软件包内容。
 ```
 PUT https://gitea.example.com/api/packages/{owner}/conda/{channel}/{filename}
 ```
 | 占位符     | 描述                                                                                                |
 | ---------- | --------------------------------------------------------------------------------------------------- |
 | `owner`    | 软件包的所有者                                                                                      |
 | `channel`  | 软件包的[通道](https://conda.io/projects/conda/en/latest/user-guide/concepts/channels.html)（可选） |
 | `filename` | 文件名                                                                                              |
 使用HTTP基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/package-1.0.conda \
     https://gitea.example.com/api/packages/testuser/conda/package-1.0.conda
 ```
 如果已经存在同名和版本的软件包，则无法发布软件包。您必须先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表中安装软件包，请执行以下命令之一：
 ```shell
 conda install {package_name}
 conda install {package_name}={package_version}
 conda install -c {channel} {package_name}
 ```
 | 参数              | 描述                 |
 | ----------------- | -------------------- |
 | `package_name`    | 软件包的名称         |
 | `package_version` | 软件包的版本         |
 | `channel`         | 软件包的通道（可选） |
--- a/docs/content/doc/packages/container.zh-cn.md
+++ b/docs/content/doc/packages/container.zh-cn.md
@ -0,0 +1,94 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "容器注册表"
 slug: "container"
 weight: 30
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "容器"
    weight: 30
    identifier: "container"
 ---
 # 容器注册表
 为您的用户或组织发布符合  [Open Container Initiative(OCI)](https://opencontainers.org/) 规范的镜像。
 该容器注册表遵循 OCI 规范，并支持所有兼容的镜像类型，如 [Docker](https://www.docker.com/) 和 [Helm Charts](https://helm.sh/)。
 **目录**
 {{< toc >}}
 ## 目录
 要使用容器注册表，您可以使用适用于特定镜像类型的工具。
 以下示例使用 `docker` 客户端。
 ## 登录容器注册表
 要推送镜像或者如果镜像位于私有注册表中，您需要进行身份验证：
 ```shell
 docker login gitea.example.com
 ```
 如果您使用的是 2FA 或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})替代密码进行身份验证。
 ## 镜像命名约定
 镜像必须遵循以下命名约定：
 `{registry}/{owner}/{image}`
 例如，以下是所有者为 `testuser` 的有效镜像名称示例：
 `gitea.example.com/testuser/myimage`
 `gitea.example.com/testuser/my-image`
 `gitea.example.com/testuser/my/image`
 **注意:** 该注册表仅支持大小写不敏感的标签名称。因此，`image:tag` 和 `image:Tag` 将被视为相同的镜像和标签。
 ## 推送镜像
 通过执行以下命令来推送镜像：
 ```shell
 docker push gitea.example.com/{owner}/{image}:{tag}
 ```
 | 参数    | 描述         |
 | ------- | ------------ |
 | `owner` | 镜像的所有者 |
 | `image` | 镜像的名称   |
 | `tag`   | 镜像的标签   |
 例如：
 ```shell
 docker push gitea.example.com/testuser/myimage:latest
 ```
 ## 拉取镜像
 通过执行以下命令来拉取镜像：
 ```shell
 docker pull gitea.example.com/{owner}/{image}:{tag}
 ```
 | Parameter | Description  |
 | --------- | ------------ |
 | `owner`   | 镜像的所有者 |
 | `image`   | 镜像的名称   |
 | `tag`     | 镜像的标签   |
 例如：
 ```shell
 docker pull gitea.example.com/testuser/myimage:latest
 ```
--- a/docs/content/doc/packages/cran.zh-cn.md
+++ b/docs/content/doc/packages/cran.zh-cn.md
@ -0,0 +1,93 @@
 ---
 date: "2023-01-01T00:00:00+00:00"
 title: "CRAN 软件包注册表"
 slug: "cran"
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "CRAN"
    weight: 35
    identifier: "cran"
 ---
 # CRAN 软件包注册表
 将 [R](https://www.r-project.org/) 软件包发布到您的用户或组织的类似 [CRAN](https://cran.r-project.org/) 的注册表。
 **目录**
 {{< toc >}}
 ## 要求
 要使用CRAN软件包注册表，您需要安装 [R](https://cran.r-project.org/)。
 ## 配置软件包注册表
 要注册软件包注册表，您需要将其添加到 `Rprofile.site` 文件中，可以是系统级别、用户级别 `~/.Rprofile` 或项目级别：
 ```
 options("repos" = c(getOption("repos"), c(gitea="https://gitea.example.com/api/packages/{owner}/cran")))
 ```
 | 参数    | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 如果需要提供凭据，可以将它们嵌入到URL(`https://user:password@gitea.example.com/...`)中。
 ## 发布软件包
 要发布 R 软件包，请执行带有软件包内容的 HTTP `PUT` 操作。
 源代码软件包：
 ```
 PUT https://gitea.example.com/api/packages/{owner}/cran/src
 ```
 | 参数    | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 二进制软件包：
 ```
 PUT https://gitea.example.com/api/packages/{owner}/cran/bin?platform={platform}&rversion={rversion}
 ```
 | 参数       | 描述           |
 | ---------- | -------------- |
 | `owner`    | 软件包的所有者 |
 | `platform` | 平台的名称     |
 | `rversion` | 二进制的R版本  |
 例如：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/package.zip \
     https://gitea.example.com/api/packages/testuser/cran/bin?platform=windows&rversion=4.2
 ```
 如果同名和版本的软件包已存在，则无法发布软件包。您必须首先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表中安装R软件包，请执行以下命令：
 ```shell
 install.packages("{package_name}")
 ```
 | 参数           | 描述              |
 | -------------- | ----------------- |
 | `package_name` | The package name. |
 例如：
 ```shell
 install.packages("testpackage")
 ```
--- a/docs/content/doc/packages/debian.zh-cn.md
+++ b/docs/content/doc/packages/debian.zh-cn.md
@ -0,0 +1,134 @@
 ---
 date: "2023-01-07T00:00:00+00:00"
 title: "Debian 软件包注册表"
 slug: "debian"
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Debian"
    weight: 35
    identifier: "debian"
 ---
 # Debian 软件包注册表
 为您的用户或组织发布 [Debian](https://www.debian.org/distrib/packages) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 Debian 注册表，您需要使用类似于 `curl` 的 HTTP 客户端进行上传，并使用类似于 `apt` 的软件包管理器消费软件包。
 以下示例使用 `apt`。
 ## 配置软件包注册表
 要注册 Debian 注册表，请将 URL 添加到已知 `apt` 源列表中：
 ```shell
 echo "deb https://gitea.example.com/api/packages/{owner}/debian {distribution} {component}" | sudo tee -a /etc/apt/sources.list.d/gitea.list
 ```
 | 占位符         | 描述           |
 | -------------- | -------------- |
 | `owner`        | 软件包的所有者 |
 | `distribution` | 要使用的发行版 |
 | `component`    | 要使用的组件   |
 如果注册表是私有的，请在 URL 中提供凭据。您可以使用密码或[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})：
 ```shell
 echo "deb https://{username}:{your_password_or_token}@gitea.example.com/api/packages/{owner}/debian {distribution} {component}" | sudo tee -a /etc/apt/sources.list.d/gitea.list
 ```
 Debian 注册表文件使用 PGP 密钥进行签名，`apt` 必须知道该密钥：
 ```shell
 sudo curl https://gitea.example.com/api/packages/{owner}/debian/repository.key -o /etc/apt/trusted.gpg.d/gitea-{owner}.asc
 ```
 然后更新本地软件包索引：
 ```shell
 apt update
 ```
 ## 发布软件包
 要发布一个 Debian 软件包（`*.deb`），执行 HTTP `PUT` 操作，并将软件包内容放入请求主体中。
 ```
 PUT https://gitea.example.com/api/packages/{owner}/debian/pool/{distribution}/{component}/upload
 ```
 | 参数           | 描述                                                  |
 | -------------- | ----------------------------------------------------- |
 | `owner`        | 软件包的所有者                                        |
 | `distribution` | 发行版，可能与操作系统的发行版名称匹配，例如 `bionic` |
 | `component`    | 组件，可用于分组软件包，或仅为 `main` 或类似的组件。  |
 使用 HTTP 基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/file.deb \
     https://gitea.example.com/api/packages/testuser/debian/pool/bionic/main/upload
 ```
 如果您使用 2FA 或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})替代密码。
 您无法向软件包中多次发布具有相同名称的文件。您必须首先删除现有的软件包版本。
 服务器将使用以下 HTTP 状态代码进行响应。
 | HTTP 状态码       | 意义                                     |
 | ----------------- | ---------------------------------------- |
 | `201 Created`     | 软件包已发布                             |
 | `400 Bad Request` | 软件包名称、版本、发行版、组件或架构无效 |
 | `409 Conflict`    | 具有相同参数组合的软件包文件已经存在     |
 ## 删除软件包
 要删除 Debian 软件包，请执行 HTTP `DELETE` 操作。如果没有文件留下，这将同时删除软件包版本。
 ```
 DELETE https://gitea.example.com/api/packages/{owner}/debian/pool/{distribution}/{component}/{package_name}/{package_version}/{architecture}
 ```
 | 参数              | 描述           |
 | ----------------- | -------------- |
 | `owner`           | 软件包的所有者 |
 | `package_name`    | 软件包名称     |
 | `package_version` | 软件包版本     |
 | `distribution`    | 软件包发行版   |
 | `component`       | 软件包组件     |
 | `architecture`    | 软件包架构     |
 使用 HTTP 基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_token_or_password -X DELETE \
     https://gitea.example.com/api/packages/testuser/debian/pools/bionic/main/test-package/1.0.0/amd64
 ```
 服务器将使用以下 HTTP 状态代码进行响应。
 | HTTP 状态码      | 含义               |
 | ---------------- | ------------------ |
 | `204 No Content` | 成功               |
 | `404 Not Found`  | 找不到软件包或文件 |
 ## 安装软件包
 要从 Debian 注册表安装软件包，请执行以下命令:
 ```shell
 # use latest version
 apt install {package_name}
 # use specific version
 apt install {package_name}={package_version}
 ```
--- a/docs/content/doc/packages/generic.zh-cn.md
+++ b/docs/content/doc/packages/generic.zh-cn.md
@ -0,0 +1,148 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "通用软件包注册表"
 slug: "generic"
 weight: 40
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "通用"
    weight: 40
    identifier: "generic"
 ---
 # 通用软件包注册表
 发布通用文件，如发布二进制文件或其他输出，供您的用户或组织使用。
 **目录**
 {{< toc >}}
 ## 身份验证软件包注册表
 要身份验证软件包注册表，您需要提供[自定义 HTTP 头或使用 HTTP 基本身份验证]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})。
 ## 发布软件包
 要发布通用软件包，请执行 HTTP `PUT` 操作，并将软件包内容放入请求主体中。
 您无法向软件包中多次发布具有相同名称的文件。您必须首先删除现有的软件包版本。
 ```
 PUT https://gitea.example.com/api/packages/{owner}/generic/{package_name}/{package_version}/{file_name}
 ```
 | 参数              | 描述                                                                                                                        |
 | ----------------- | --------------------------------------------------------------------------------------------------------------------------- |
 | `owner`           | 软件包的所有者。                                                                                                            |
 | `package_name`    | 软件包名称。它只能包含小写字母 (`a-z`)、大写字母 (`A-Z`)、数字 (`0-9`)、点号 (`.`)、连字符 (`-`)、加号 (`+`) 或下划线 (`_`) |
 | `package_version` | 软件包版本，一个非空字符串，不包含前导或尾随空格                                                                            |
 | `file_name`       | 文件名。它只能包含小写字母 (`a-z`)、大写字母 (`A-Z`)、数字 (`0-9`)、点号 (`.`)、连字符 (`-`)、加号 (`+`) 或下划线 (`_`)     |
 使用 HTTP 基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/file.bin \
     https://gitea.example.com/api/packages/testuser/generic/test_package/1.0.0/file.bin
 ```
 如果您使用 2FA 或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})替代密码。
 服务器将使用以下 HTTP 状态代码进行响应。
 | HTTP 状态码       | 意义                               |
 | ----------------- | ---------------------------------- |
 | `201 Created`     | 软件包已发布                       |
 | `400 Bad Request` | 软件包名称和/或版本和/或文件名无效 |
 | `409 Conflict`    | 具有相同名称的文件已存在于软件包中 |
 ## 下载软件包
 要下载通用软件包，请执行 HTTP `GET` 操作。
 ```
 GET https://gitea.example.com/api/packages/{owner}/generic/{package_name}/{package_version}/{file_name}
 ```
 | 参数              | 描述           |
 | ----------------- | -------------- |
 | `owner`           | 软件包的所有者 |
 | `package_name`    | 软件包名称     |
 | `package_version` | 软件包版本     |
 | `file_name`       | 文件名         |
 文件内容将在响应主体中返回。响应的内容类型为 `application/octet-stream`。
 服务器将使用以下 HTTP 状态代码进行响应。
 ```shell
 curl --user your_username:your_token_or_password \
     https://gitea.example.com/api/packages/testuser/generic/test_package/1.0.0/file.bin
 ```
 服务器会以以下 HTTP 状态码进行响应：
 | HTTP 状态码     | 含义                 |
 | --------------- | -------------------- |
 | `200 OK`        | 成功                 |
 | `404 Not Found` | 找不到软件包或者文件 |
 ## 删除软件包
 要删除通用软件包，请执行 HTTP DELETE 操作。这将同时删除该版本的所有文件。
 ```
 DELETE https://gitea.example.com/api/packages/{owner}/generic/{package_name}/{package_version}
 ```
 | 参数              | 描述           |
 | ----------------- | -------------- |
 | `owner`           | 软件包的所有者 |
 | `package_name`    | 软件包名称     |
 | `package_version` | 软件包版本     |
 服务器将使用以下 HTTP 状态代码进行响应。
 ```shell
 curl --user your_username:your_token_or_password -X DELETE \
     https://gitea.example.com/api/packages/testuser/generic/test_package/1.0.0
 ```
 The server responds with the following HTTP Status codes.
 | HTTP 状态码      | 意义         |
 | ---------------- | ------------ |
 | `204 No Content` | 成功         |
 | `404 Not Found`  | 找不到软件包 |
 ## 删除软件包文件
 要删除通用软件包的文件，请执行 HTTP `DELETE` 操作。如果没有文件留下，这将同时删除软件包版本。
 ```
 DELETE https://gitea.example.com/api/packages/{owner}/generic/{package_name}/{package_version}/{filename}
 ```
 | 参数              | 描述           |
 | ----------------- | -------------- |
 | `owner`           | 软件包的所有者 |
 | `package_name`    | 软件包名称     |
 | `package_version` | 软件包版本     |
 | `filename`        | 文件名         |
 使用 HTTP 基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_token_or_password -X DELETE \
     https://gitea.example.com/api/packages/testuser/generic/test_package/1.0.0/file.bin
 ```
 服务器将使用以下 HTTP 状态代码进行响应：
 | HTTP 状态码      | 含义               |
 | ---------------- | ------------------ |
 | `204 No Content` | 成功               |
 | `404 Not Found`  | 找不到软件包或文件 |
--- a/docs/content/doc/packages/go.zh-cn.md
+++ b/docs/content/doc/packages/go.zh-cn.md
@ -0,0 +1,77 @@
 ---
 date: "2023-05-10T00:00:00+00:00"
 title: "Go 软件包注册表"
 slug: "go"
 weight: 45
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Go"
    weight: 45
    identifier: "go"
 ---
 # Go 软件包注册表
 为您的用户或组织发布 Go 软件包。
 **目录**
 {{< toc >}}
 ## 发布软件包
 要发布 Go 软件包，请执行 HTTP `PUT` 操作，并将软件包内容放入请求主体中。
 如果已经存在相同名称和版本的软件包，您无法发布软件包。您必须首先删除现有的软件包。
 该软件包必须遵循[文档中的结构](https://go.dev/ref/mod#zip-files)。
 ```
 PUT https://gitea.example.com/api/packages/{owner}/go/upload
 ```
 | 参数    | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 要身份验证到软件包注册表，您需要提供[自定义 HTTP 头或使用 HTTP 基本身份验证]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/file.zip \
     https://gitea.example.com/api/packages/testuser/go/upload
 ```
 如果您使用的是 2FA 或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})替代密码进行身份验证。
 服务器将使用以下 HTTP 状态代码进行响应。
 | HTTP 状态码       | 含义                       |
 | ----------------- | -------------------------- |
 | `201 Created`     | 软件包已发布               |
 | `400 Bad Request` | 软件包无效                 |
 | `409 Conflict`    | 具有相同名称的软件包已存在 |
 ## 安装软件包
 要安装Go软件包，请指示Go使用软件包注册表作为代理：
 ```shell
 # 使用最新版本
 GOPROXY=https://gitea.example.com/api/packages/{owner}/go go install {package_name}
 # 或者
 GOPROXY=https://gitea.example.com/api/packages/{owner}/go go install {package_name}@latest
 # 使用特定版本
 GOPROXY=https://gitea.example.com/api/packages/{owner}/go go install {package_name}@{package_version}
 ```
 | 参数              | 描述           |
 | ----------------- | -------------- |
 | `owner`           | 软件包的所有者 |
 | `package_name`    | 软件包名称     |
 | `package_version` | 软件包版本     |
 如果软件包的所有者是私有的，则需要[提供凭据](https://go.dev/ref/mod#private-module-proxy-auth)。
 有关 `GOPROXY` 环境变量的更多信息以及如何防止数据泄漏的信息，请[参阅文档](https://go.dev/ref/mod#private-modules)。
--- a/docs/content/doc/packages/helm.zh-cn.md
+++ b/docs/content/doc/packages/helm.zh-cn.md
@ -0,0 +1,68 @@
 ---
 date: "2022-04-14T00:00:00+00:00"
 title: "Helm Chart 注册表"
 slug: "helm"
 weight: 50
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Helm"
    weight: 50
    identifier: "helm"
 ---
 # Helm Chart 注册表
 为您的用户或组织发布 [Helm](https://helm.sh/) charts。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 Helm Chart 注册表，可以使用诸如 `curl` 或 [`helm cm-push`](https://github.com/chartmuseum/helm-push/) 插件之类的简单HTTP客户端。
 ## 发布软件包
 通过运行以下命令来发布软件包：
 ```shell
 curl --user {username}:{password} -X POST --upload-file ./{chart_file}.tgz https://gitea.example.com/api/packages/{owner}/helm/api/charts
 ```
 或者使用 `helm cm-push` 插件：
 ```shell
 helm repo add  --username {username} --password {password} {repo} https://gitea.example.com/api/packages/{owner}/helm
 helm cm-push ./{chart_file}.tgz {repo}
 ```
 | 参数         | 描述                                                                                                                                                   |
 | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `username`   | 您的Gitea用户名                                                                                                                                        |
 | `password`   | 您的Gitea密码。如果您使用的是2FA或OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})替代密码进行身份验证。 |
 | `repo`       | 仓库名称                                                                                                                                               |
 | `chart_file` | Helm Chart 归档文件                                                                                                                                    |
 | `owner`      | 软件包的所有者                                                                                                                                         |
 ## 安装软件包
 要从注册表中安装Helm Chart，请执行以下命令：
 ```shell
 helm repo add  --username {username} --password {password} {repo} https://gitea.example.com/api/packages/{owner}/helm
 helm repo update
 helm install {name} {repo}/{chart}
 ```
 | 参数       | 描述                        |
 | ---------- | --------------------------- |
 | `username` | 您的Gitea用户名             |
 | `password` | 您的Gitea密码或个人访问令牌 |
 | `repo`     | 存储库的名称                |
 | `owner`    | 软件包的所有者              |
 | `name`     | 本地名称                    |
 | `chart`    | Helm Chart的名称            |
--- a/docs/content/doc/packages/maven.zh-cn.md
+++ b/docs/content/doc/packages/maven.zh-cn.md
@ -0,0 +1,167 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "Maven 软件包注册表"
 slug: "maven"
 weight: 60
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Maven"
    weight: 60
    identifier: "maven"
 ---
 # Maven 软件包注册表
 为您的用户或组织发布 [Maven](https://maven.apache.org) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 Maven 软件包注册表，您可以使用 [Maven](https://maven.apache.org/install.html) 或 [Gradle](https://gradle.org/install/)。
 以下示例使用 `Maven` 和 `Gradle Groovy`。
 ## 配置软件包注册表
 要注册软件包注册表，首先需要将访问令牌添加到 [`settings.xml`](https://maven.apache.org/settings.html) 文件中：
 ```xml
 <settings>
  <servers>
    <server>
      <id>gitea</id>
      <configuration>
        <httpHeaders>
          <property>
            <name>Authorization</name>
            <value>token {access_token}</value>
          </property>
        </httpHeaders>
      </configuration>
    </server>
  </servers>
 </settings>
 ```
 然后在项目的 `pom.xml` 文件中添加以下部分：
 ```xml
 <repositories>
  <repository>
    <id>gitea</id>
    <url>https://gitea.example.com/api/packages/{owner}/maven</url>
  </repository>
 </repositories>
 <distributionManagement>
  <repository>
    <id>gitea</id>
    <url>https://gitea.example.com/api/packages/{owner}/maven</url>
  </repository>
  <snapshotRepository>
    <id>gitea</id>
    <url>https://gitea.example.com/api/packages/{owner}/maven</url>
  </snapshotRepository>
 </distributionManagement>
 ```
 | 参数           | 描述                                                                                  |
 | -------------- | ------------------------------------------------------------------------------------- |
 | `access_token` | 您的[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}}) |
 | `owner`        | 软件包的所有者                                                                        |
 ### Gradle variant
 如果您计划在项目中添加来自 Gitea 实例的一些软件包，请将其添加到 repositories 部分中：
 ```groovy
 repositories {
    // other repositories
    maven { url "https://gitea.example.com/api/packages/{owner}/maven" }
 }
 ```
 在 Groovy gradle 中，您可以在发布部分中包含以下脚本：
 ```groovy
 publishing {
    // 其他发布设置
    repositories {
        maven {
            name = "Gitea"
            url = uri("https://gitea.example.com/api/packages/{owner}/maven")
            credentials(HttpHeaderCredentials) {
                name = "Authorization"
                value = "token {access_token}"
            }
            authentication {
                header(HttpHeaderAuthentication)
            }
        }
    }
 }
 ```
 ## 发布软件包
 要发布软件包，只需运行以下命令：
 ```shell
 mvn deploy
 ```
 或者，如果您使用的是 Gradle，请使用 `gradle` 命令和 `publishAllPublicationsToGiteaRepository` 任务：
 ```groovy
 ./gradlew publishAllPublicationsToGiteaRepository
 ```
 如果您想要将预构建的软件包发布到注册表中，可以使用 [`mvn deploy:deploy-file`](https://maven.apache.org/plugins/maven-deploy-plugin/deploy-file-mojo.html) 命令：
 ```shell
 mvn deploy:deploy-file -Durl=https://gitea.example.com/api/packages/{owner}/maven -DrepositoryId=gitea -Dfile=/path/to/package.jar
 ```
 | 参数    | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 如果存在相同名称和版本的软件包，您无法发布该软件包。您必须先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表中安装 Maven 软件包，请在项目的 `pom.xml` 文件中添加新的依赖项：
 ```xml
 <dependency>
  <groupId>com.test.package</groupId>
  <artifactId>test_project</artifactId>
  <version>1.0.0</version>
 </dependency>
 ```
 在 `Gradle Groovy` 中类似的操作如下：
 ```groovy
 implementation "com.test.package:test_project:1.0.0"
 ```
 然后运行：
 ```shell
 mvn install
 ```
 ## 支持的命令
 ```
 mvn install
 mvn deploy
 mvn dependency:get:
 ```
--- a/docs/content/doc/packages/npm.zh-cn.md
+++ b/docs/content/doc/packages/npm.zh-cn.md
@ -0,0 +1,145 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "npm 软件包注册表"
 slug: "npm"
 weight: 70
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "npm"
    weight: 70
    identifier: "npm"
 ---
 # npm Package Registry
 为您的用户或组织发布 [npm](https://www.npmjs.com/) 包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 npm 包注册表，您需要安装 [Node.js](https://nodejs.org/en/download/)  以及与之配套的软件包管理器，例如 [Yarn](https://classic.yarnpkg.com/en/docs/install) 或 [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm/) 本身。
 该注册表支持[作用域](https://docs.npmjs.com/misc/scope/)和非作用域软件包。
 以下示例使用具有作用域 `@test` 的 `npm` 工具。
 ## 配置软件包注册表
 要注册软件包注册表，您需要配置一个新的软件包源。
 ```shell
 npm config set {scope}:registry https://gitea.example.com/api/packages/{owner}/npm/
 npm config set -- '//gitea.example.com/api/packages/{owner}/npm/:_authToken' "{token}"
 ```
 | 参数    | 描述                                                                                    |
 | ------- | --------------------------------------------------------------------------------------- |
 | `scope` | 软件包的作用域                                                                          |
 | `owner` | 软件包的所有者                                                                          |
 | `token` | 您的[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})。 |
 例如：
 ```shell
 npm config set @test:registry https://gitea.example.com/api/packages/testuser/npm/
 npm config set -- '//gitea.example.com/api/packages/testuser/npm/:_authToken' "personal_access_token"
 ```
 或者，不使用作用域：
 ```shell
 npm config set registry https://gitea.example.com/api/packages/testuser/npm/
 npm config set -- '//gitea.example.com/api/packages/testuser/npm/:_authToken' "personal_access_token"
 ```
 ## 发布软件包
 在项目中运行以下命令发布软件包：
 ```shell
 npm publish
 ```
 如果已经存在相同名称和版本的软件包，您无法发布该软件包。您必须先删除现有的软件包。
 ## 删除软件包
 通过运行以下命令删除软件包：
 ```shell
 npm unpublish {package_name}[@{package_version}]
 ```
 | 参数              | 描述       |
 | ----------------- | ---------- |
 | `package_name`    | 软件包名称 |
 | `package_version` | 软件包版本 |
 例如
 ```shell
 npm unpublish @test/test_package
 npm unpublish @test/test_package@1.0.0
 ```
 ## 安装软件包
 要从软件包注册表中安装软件包，请执行以下命令：
 ```shell
 npm install {package_name}
 ```
 | 参数           | 描述       |
 | -------------- | ---------- |
 | `package_name` | 软件包名称 |
 例如：
 ```shell
 npm install @test/test_package
 ```
 ## 给软件包打标签
 该注册表支持[版本标签](https://docs.npmjs.com/adding-dist-tags-to-packages/)，可以通过 `npm dist-tag` 管理：
 ```shell
 npm dist-tag add {package_name}@{version} {tag}
 ```
 | 参数           | 描述       |
 | -------------- | ---------- |
 | `package_name` | 软件包名称 |
 | `version`      | 软件包版本 |
 | `tag`          | 软件包标签 |
 例如：
 ```shell
 npm dist-tag add test_package@1.0.2 release
 ```
 标签名称不能是有效的版本。所有可解析为版本的标签名称都将被拒绝。
 ## 搜索软件包
 该注册表支持[搜索](https://docs.npmjs.com/cli/v7/commands/npm-search/)，但不支持像 `author:gitea` 这样的特殊搜索限定符。
 ## 支持的命令
 ```
 npm install
 npm ci
 npm publish
 npm unpublish
 npm dist-tag
 npm view
 npm search
 ```
--- a/docs/content/doc/packages/nuget.zh-cn.md
+++ b/docs/content/doc/packages/nuget.zh-cn.md
@ -0,0 +1,118 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "NuGet 软件包注册表"
 slug: "nuget"
 weight: 80
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "NuGet"
    weight: 80
    identifier: "nuget"
 ---
 # NuGet 软件包注册表
 发布适用于您的用户或组织的 [NuGet](https://www.nuget.org/) 软件包。软件包注册表支持 V2 和 V3 API 协议，并且您还可以使用 [NuGet 符号软件包](https://docs.microsoft.com/en-us/nuget/create-packages/symbol-packages-snupkg)。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 NuGet 软件包注册表，您可以使用命令行界面工具，以及各种集成开发环境（IDE）中的 NuGet 功能，如 Visual Studio。有关 NuGet 客户端的更多信息，请参[阅官方文档](https://docs.microsoft.com/en-us/nuget/install-nuget-client-tools)。
 以下示例使用 `dotnet nuget` 工具。
 ## 配置软件包注册表
 要注册软件包注册表，您需要配置一个新的NuGet源：
 ```shell
 dotnet nuget add source --name {source_name} --username {username} --password {password} https://gitea.example.com/api/packages/{owner}/nuget/index.json
 ```
 | 参数          | 描述                                                                                                                                   |
 | ------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
 | `source_name` | 所需源名称                                                                                                                             |
 | `username`    | 您的Gitea用户名                                                                                                                        |
 | `password`    | 您的Gitea密码。如果您使用2FA或OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})代替密码。 |
 | `owner`       | 软件包的所有者                                                                                                                         |
 例如：
 ```shell
 dotnet nuget add source --name gitea --username testuser --password password123 https://gitea.example.com/api/packages/testuser/nuget/index.json
 ```
 您可以在不提供凭据的情况下添加源，并在发布软件包时使用--api-key参数。在这种情况下，您需要提供[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})。
 ## 发布软件包
 通过运行以下命令发布软件包：
 ```shell
 dotnet nuget push --source {source_name} {package_file}
 ```
 | 参数           | 描述                         |
 | -------------- | ---------------------------- |
 | `source_name`  | 所需源名称                   |
 | `package_file` | 软件包 `.nupkg` 文件的路径。 |
 例如：
 ```shell
 dotnet nuget push --source gitea test_package.1.0.0.nupkg
 ```
 如果已经存在相同名称和版本的软件包，您无法发布该软件包。您必须先删除现有的软件包。
 ### 符号软件包
 NuGet 软件包注册表支持构建用于符号服务器的符号软件包。客户端可以请求嵌入在符号软件包（`.snupkg`）中的 PDB 文件。
 为此，请将 NuGet 软件包注册表注册为符号源：
 ```
 https://gitea.example.com/api/packages/{owner}/nuget/symbols
 ```
 | 参数    | 描述                 |
 | ------- | -------------------- |
 | `owner` | 软件包注册表的所有者 |
 例如：
 ```
 https://gitea.example.com/api/packages/testuser/nuget/symbols
 ```
 ## 安装软件包
 要从软件包注册表安装 NuGet 软件包，请执行以下命令：
 ```shell
 dotnet add package --source {source_name} --version {package_version} {package_name}
 ```
 | 参数              | 描述         |
 | ----------------- | ------------ |
 | `source_name`     | 所需源名称   |
 | `package_name`    | 软件包名称   |
 | `package_version` | 软件包版本。 |
 例如：
 ```shell
 dotnet add package --source gitea --version 1.0.0 test_package
 ```
 ## 支持的命令
 ```
 dotnet add
 dotnet nuget push
 dotnet nuget delete
 ```
--- a/docs/content/doc/packages/overview.zh-cn.md
+++ b/docs/content/doc/packages/overview.zh-cn.md
@ -0,0 +1,109 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "软件包注册表"
 slug: "overview"
 weight: 1
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Overview"
    weight: 1
    identifier: "packages-overview"
 ---
 # 软件包注册表
 从Gitea **1.17**版本开始，软件包注册表可以用作常见软件包管理器的公共或私有注册表。
 **目录**
 {{< toc >}}
 ## 支持的软件包管理器
 目前支持以下软件包管理器：
 | Name                                                          | Language   | Package client            |
 | ------------------------------------------------------------- | ---------- | ------------------------- |
 | [Alpine]({{< relref "doc/packages/alpine.zh-cn.md" >}})       | -          | `apk`                     |
 | [Cargo]({{< relref "doc/packages/cargo.zh-cn.md" >}})         | Rust       | `cargo`                   |
 | [Chef]({{< relref "doc/packages/chef.zh-cn.md" >}})           | -          | `knife`                   |
 | [Composer]({{< relref "doc/packages/composer.zh-cn.md" >}})   | PHP        | `composer`                |
 | [Conan]({{< relref "doc/packages/conan.zh-cn.md" >}})         | C++        | `conan`                   |
 | [Conda]({{< relref "doc/packages/conda.zh-cn.md" >}})         | -          | `conda`                   |
 | [Container]({{< relref "doc/packages/container.zh-cn.md" >}}) | -          | 任何符合OCI规范的客户端   |
 | [CRAN]({{< relref "doc/packages/cran.zh-cn.md" >}})           | R          | -                         |
 | [Debian]({{< relref "doc/packages/debian.zh-cn.md" >}})       | -          | `apt`                     |
 | [Generic]({{< relref "doc/packages/generic.zh-cn.md" >}})     | -          | 任何HTTP客户端            |
 | [Go]({{< relref "doc/packages/go.zh-cn.md" >}})               | Go         | `go`                      |
 | [Helm]({{< relref "doc/packages/helm.zh-cn.md" >}})           | -          | 任何HTTP客户端, `cm-push` |
 | [Maven]({{< relref "doc/packages/maven.zh-cn.md" >}})         | Java       | `mvn`, `gradle`           |
 | [npm]({{< relref "doc/packages/npm.zh-cn.md" >}})             | JavaScript | `npm`, `yarn`, `pnpm`     |
 | [NuGet]({{< relref "doc/packages/nuget.zh-cn.md" >}})         | .NET       | `nuget`                   |
 | [Pub]({{< relref "doc/packages/pub.zh-cn.md" >}})             | Dart       | `dart`, `flutter`         |
 | [PyPI]({{< relref "doc/packages/pypi.zh-cn.md" >}})           | Python     | `pip`, `twine`            |
 | [RPM]({{< relref "doc/packages/rpm.zh-cn.md" >}})             | -          | `yum`, `dnf`              |
 | [RubyGems]({{< relref "doc/packages/rubygems.zh-cn.md" >}})   | Ruby       | `gem`, `Bundler`          |
 | [Swift]({{< relref "doc/packages/rubygems.zh-cn.md" >}})      | Swift      | `swift`                   |
 | [Vagrant]({{< relref "doc/packages/vagrant.zh-cn.md" >}})     | -          | `vagrant`                 |
 **以下段落仅适用于未全局禁用软件包的情况！**
 ## 仓库 x 软件包
 软件包始终属于所有者（用户或组织），而不是仓库。
 要将（已上传的）软件包链接到仓库，请打开该软件包的设置页面，并选择要将此软件包链接到的仓库。
 将链接到整个软件包，而不仅是单个版本。
 链接软件包将导致在仓库的软件包列表中显示该软件包，并在软件包页面上显示到仓库的链接（以及到仓库工单的链接）。
 ## 访问限制
 | 软件包所有者类型 | 用户                                     | 组织                                       |
 | ---------------- | ---------------------------------------- | ------------------------------------------ |
 | **读取** 访问    | 公开，如果用户也是公开的；否则仅限此用户 | 公开，如果组织是公开的，否则仅限组织成员   |
 | **写入** 访问    | 仅软件包所有者                           | 具有组织中的管理员或写入访问权限的组织成员 |
 注意：这些访问限制可能会[变化](https://github.com/go-gitea/gitea/issues/19270)，将通过专门的组织团队权限添加更细粒度的控制。
 ## 创建或上传软件包
 根据软件包类型，使用相应的软件包管理器。请查看特定软件包管理器的子页面以获取说明。
 ## 查看软件包
 您可以在仓库页面上查看仓库的软件包。
 1. 转到仓库主页。
 2. 在导航栏中选择**软件包**
 要查看有关软件包的更多详细信息，请选择软件包的名称。
 ## 下载软件包
 要从仓库下载软件包：
 1. 在导航栏中选择**软件包**
 2. 选择软件包的名称以查看详细信息。
 3. 在 **Assets** 部分，选择要下载的软件包文件的名称。
 ## 删除软件包
 在将软件包发布到软件包注册表后，您无法编辑软件包。相反，您必须删除并重新创建它。
 要从仓库中删除软件包：
 1. 在导航栏中选择**软件包**
 2. 选择软件包的名称以查看详细信息。
 3. 单击**删除软件包**以永久删除软件包。
 ## 禁用软件包注册表
 包注册表已自动启用。要在单个存储库中禁用它：
 1. 在导航栏中选择**设置**。
 2. 禁用**启用仓库软件包注册表**.
 禁用软件包注册表不会删除先前发布的软件包。
--- a/docs/content/doc/packages/pub.zh-cn.md
+++ b/docs/content/doc/packages/pub.zh-cn.md
@ -0,0 +1,84 @@
 ---
 date: "2022-07-31T00:00:00+00:00"
 title: "Pub 软件包注册表"
 slug: "pub"
 weight: 90
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Pub"
    weight: 90
    identifier: "pub"
 ---
 # Pub 软件包注册表
 为您的用户或组织发布 [Pub](https://dart.dev/guides/packages) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用Pub软件包注册表，您需要使用 [dart](https://dart.dev/tools/dart-tool) 和/或 [flutter](https://docs.flutter.dev/reference/flutter-cli). 工具。
 以下示例使用 `dart`。
 ## 配置软件包注册表
 要注册软件包注册表并提供凭据，请执行以下操作：
 ```shell
 dart pub token add https://gitea.example.com/api/packages/{owner}/pub
 ```
 | 占位符  | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 您需要提供您的[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})。
 ## 发布软件包
 要发布软件包，请编辑 `pubspec.yaml` 文件，并添加以下行：
 ```yaml
 publish_to: https://gitea.example.com/api/packages/{owner}/pub
 ```
 | 占位符  | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 现在，您可以通过运行以下命令来发布软件包：
 ```shell
 dart pub publish
 ```
 如果已存在具有相同名称和版本的软件包，则无法发布软件包。您必须先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表安装Pub软件包，请执行以下命令：
 ```shell
 dart pub add {package_name} --hosted-url=https://gitea.example.com/api/packages/{owner}/pub/
 ```
 | 参数           | 描述           |
 | -------------- | -------------- |
 | `owner`        | 软件包的所有者 |
 | `package_name` | 软件包名称     |
 例如：
 ```shell
 # use latest version
 dart pub add mypackage --hosted-url=https://gitea.example.com/api/packages/testuser/pub/
 # specify version
 dart pub add mypackage:1.0.8 --hosted-url=https://gitea.example.com/api/packages/testuser/pub/
 ```
--- a/docs/content/doc/packages/pypi.zh-cn.md
+++ b/docs/content/doc/packages/pypi.zh-cn.md
@ -0,0 +1,88 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "PyPI 软件包注册表"
 slug: "pypi"
 weight: 100
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "PyPI"
    weight: 100
    identifier: "pypi"
 ---
 # PyPI 软件包注册表
 为您的用户或组织发布 [PyPI](https://pypi.org/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 PyPI 软件包注册表，您需要使用 [pip](https://pypi.org/project/pip/) 工具来消费和使用 [twine](https://pypi.org/project/twine/) 工具来发布软件包。
 ## 配置软件包注册表
 要注册软件包注册表，您需要编辑本地的 `~/.pypirc` 文件。添加以下内容：
 ```ini
 [distutils]
 index-servers = gitea
 [gitea]
 repository = https://gitea.example.com/api/packages/{owner}/pypi
 username = {username}
 password = {password}
 ```
 | 占位符     | 描述                                                                                                                                      |
 | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
 | `owner`    | 软件包的所有者                                                                                                                            |
 | `username` | 您的 Gitea 用户名                                                                                                                         |
 | `password` | 您的 Gitea 密码。如果您使用 2FA 或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})替代密码 |
 ## 发布软件包
 通过运行以下命令来发布软件包：
 ```shell
 python3 -m twine upload --repository gitea /path/to/files/*
 ```
 软件包文件的扩展名为 `.tar.gz` 和 `.whl`。
 如果已存在具有相同名称和版本的软件包，则无法发布软件包。您必须先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表安装 PyPI 软件包，请执行以下命令：
 ```shell
 pip install --index-url https://{username}:{password}@gitea.example.com/api/packages/{owner}/pypi/simple --no-deps {package_name}
 ```
 | 参数           | 描述                          |
 | -------------- | ----------------------------- |
 | `username`     | 您的 Gitea 用户名             |
 | `password`     | 您的 Gitea 密码或个人访问令牌 |
 | `owner`        | 软件包的所有者                |
 | `package_name` | 软件包名称                    |
 例如：
 ```shell
 pip install --index-url https://testuser:password123@gitea.example.com/api/packages/testuser/pypi/simple --no-deps test_package
 ```
 您可以使用 `--extra-index-url` 替代 `--index-url`，但这样会使您容易受到依赖混淆攻击，因为 `pip` 会先检查官方 PyPi 仓库中的软件包，然后再检查指定的自定义仓库。请阅读 `pip` 文档以获取更多信息。
 ## 支持的命令
 ```
 pip install
 twine upload
 ```
--- a/docs/content/doc/packages/rpm.zh-cn.md
+++ b/docs/content/doc/packages/rpm.zh-cn.md
@ -0,0 +1,117 @@
 ---
 date: "2023-03-08T00:00:00+00:00"
 title: "RPM 软件包注册表"
 slug: "packages/rpm"
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "RPM"
    weight: 105
    identifier: "rpm"
 ---
 # RPM 软件包注册表
 为您的用户或组织发布 [RPM](https://rpm.org/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用RPM注册表，您需要使用像 `yum` 或 `dnf` 这样的软件包管理器来消费软件包。
 以下示例使用 `dnf`。
 ## 配置软件包注册表
 要注册RPM注册表，请将 URL 添加到已知 `apt` 源列表中：
 ```shell
 dnf config-manager --add-repo https://gitea.example.com/api/packages/{owner}/rpm.repo
 ```
 | 占位符  | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 如果注册表是私有的，请在URL中提供凭据。您可以使用密码或[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})：
 ```shell
 dnf config-manager --add-repo https://{username}:{your_password_or_token}@gitea.example.com/api/packages/{owner}/rpm.repo
 ```
 您还必须将凭据添加到 `/etc/yum.repos.d` 中的 `rpm.repo` 文件中的URL中。
 ## 发布软件包
 要发布RPM软件包（`*.rpm`），请执行带有软件包内容的 HTTP `PUT` 操作。
 ```
 PUT https://gitea.example.com/api/packages/{owner}/rpm/upload
 ```
 | 参数    | 描述           |
 | ------- | -------------- |
 | `owner` | 软件包的所有者 |
 使用HTTP基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/file.rpm \
     https://gitea.example.com/api/packages/testuser/rpm/upload
 ```
 如果您使用 2FA 或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})替代密码。您无法将具有相同名称的文件两次发布到软件包中。您必须先删除现有的软件包版本。
 服务器将以以下HTTP状态码响应。
 | HTTP 状态码       | 含义                                             |
 | ----------------- | ------------------------------------------------ |
 | `201 Created`     | 软件包已发布                                     |
 | `400 Bad Request` | 软件包无效                                       |
 | `409 Conflict`    | 具有相同参数组合的软件包文件已经存在于该软件包中 |
 ## 删除软件包
 要删除 RPM 软件包，请执行 HTTP `DELETE` 操作。如果没有文件剩余，这也将删除软件包版本。
 ```
 DELETE https://gitea.example.com/api/packages/{owner}/rpm/{package_name}/{package_version}/{architecture}
 ```
 | 参数              | 描述           |
 | ----------------- | -------------- |
 | `owner`           | 软件包的所有者 |
 | `package_name`    | 软件包名称     |
 | `package_version` | 软件包版本     |
 | `architecture`    | 软件包架构     |
 使用HTTP基本身份验证的示例请求：
 ```shell
 curl --user your_username:your_token_or_password -X DELETE \
     https://gitea.example.com/api/packages/testuser/rpm/test-package/1.0.0/x86_64
 ```
 服务器将以以下HTTP状态码响应：
 | HTTP 状态码      | 含义               |
 | ---------------- | ------------------ |
 | `204 No Content` | 成功               |
 | `404 Not Found`  | 未找到软件包或文件 |
 ## 安装软件包
 要从RPM注册表安装软件包，请执行以下命令：
 ```shell
 # use latest version
 dnf install {package_name}
 # use specific version
 dnf install {package_name}-{package_version}.{architecture}
 ```
--- a/docs/content/doc/packages/rubygems.zh-cn.md
+++ b/docs/content/doc/packages/rubygems.zh-cn.md
@ -0,0 +1,128 @@
 ---
 date: "2021-07-20T00:00:00+00:00"
 title: "RubyGems 软件包注册表"
 slug: "rubygems"
 weight: 110
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "RubyGems"
    weight: 110
    identifier: "rubygems"
 ---
 # RubyGems 软件包注册表
 为您的用户或组织发布 [RubyGems](https://guides.rubygems.org/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用RubyGems软件包注册表，您需要使用 [gem](https://guides.rubygems.org/command-reference/) 命令行工具来消费和发布软件包。
 ## 配置软件包注册表
 要注册软件包注册表，请编辑 `~/.gem/credentials` 文件并添加：
 ```ini
 ---
 https://gitea.example.com/api/packages/{owner}/rubygems: Bearer {token}
 ```
 | 参数    | 描述                                                                                  |
 | ------- | ------------------------------------------------------------------------------------- |
 | `owner` | 软件包的所有者                                                                        |
 | `token` | 您的[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}}) |
 例如：
 ```
 ---
 https://gitea.example.com/api/packages/testuser/rubygems: Bearer 3bd626f84b01cd26b873931eace1e430a5773cc4
 ```
 ## 发布软件包
 通过运行以下命令来发布软件包：
 ```shell
 gem push --host {host} {package_file}
 ```
 | 参数           | 描述                     |
 | -------------- | ------------------------ |
 | `host`         | 软件包注册表的URL        |
 | `package_file` | 软件包 `.gem` 文件的路径 |
 例如：
 ```shell
 gem push --host https://gitea.example.com/api/packages/testuser/rubygems test_package-1.0.0.gem
 ```
 如果已经存在相同名称和版本的软件包，您将无法发布软件包。您必须先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表安装软件包，您可以使用 [Bundler](https://bundler.io) 或 `gem`。
 ### Bundler
 在您的 `Gemfile` 中添加一个新的 `source` 块：
 ```
 source "https://gitea.example.com/api/packages/{owner}/rubygems" do
  gem "{package_name}"
 end
 ```
 | 参数           | 描述           |
 | -------------- | -------------- |
 | `owner`        | 软件包的所有者 |
 | `package_name` | 软件包名称     |
 例如：
 ```
 source "https://gitea.example.com/api/packages/testuser/rubygems" do
  gem "test_package"
 end
 ```
 之后运行以下命令：
 ```shell
 bundle install
 ```
 ### gem
 执行以下命令：
 ```shell
 gem install --host https://gitea.example.com/api/packages/{owner}/rubygems {package_name}
 ```
 | 参数           | 描述           |
 | -------------- | -------------- |
 | `owner`        | 软件包的所有者 |
 | `package_name` | 软件包名称     |
 例如：
 ```shell
 gem install --host https://gitea.example.com/api/packages/testuser/rubygems test_package
 ```
 ## 支持的命令
 ```
 gem install
 bundle install
 gem push
 ```
--- a/docs/content/doc/packages/storage.en-us.md
+++ b/docs/content/doc/packages/storage.en-us.md
@ -77,9 +77,9 @@ The cleanup rules are part of the [clean up job]({{< relref "doc/administration/
 The cleanup rule:
 1. Collects all packages of the package type for the owners registry.
-1. For every package it collects all versions.
+2. For every package it collects all versions.
-1. Excludes from the list the # versions based on the *Keep the most recent* value.
+3. Excludes from the list the # versions based on the *Keep the most recent* value.
-1. Excludes from the list any versions matching the *Keep versions matching* value.
+4. Excludes from the list any versions matching the *Keep versions matching* value.
-1. Excludes from the list the versions more recent than the *Remove versions older than* value.
+5. Excludes from the list the versions more recent than the *Remove versions older than* value.
-1. Excludes from the list any versions not matching the *Remove versions matching* value.
+6. Excludes from the list any versions not matching the *Remove versions matching* value.
-1. Deletes the remaining versions.
+7. Deletes the remaining versions.
--- a/docs/content/doc/packages/storage.zh-cn.md
+++ b/docs/content/doc/packages/storage.zh-cn.md
@ -0,0 +1,85 @@
 ---
 date: "2022-11-01T00:00:00+00:00"
 title: "存储"
 slug: "storage"
 weight: 5
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Storage"
    weight: 2
    identifier: "storage"
 ---
 # 存储
 本文档描述了软件包注册表的存储方式以及如何管理存储。
 **目录**
 {{< toc >}}
 ## 去重
 软件包注册表具有内置的去重功能，可以对上传的 Blob 进行去重处理。
 如果上传了两个相同的文件，只会在文件系统上保存一个 Blob。
 这样可以确保不会浪费空间用于重复的文件。
 如果上传了两个具有相同文件的软件包，这两个软件包将显示相同的大小，但在文件系统上，它们只需要一半的大小。
 每当删除一个软件包时，只会删除对底层 Blob 的引用。
 此时，Blob 不会被删除，因此它们仍然占用文件系统上的空间。
 当上传新的软件包时，现有的 Blob 可能会再次被引用。
 这些无引用的 Blob 会在一个清理任务中被删除。
 配置设置 `OLDER_THAN` 可以配置无引用的 Blob 在被删除之前保留的时间。
 ## 清理规则
 软件包注册表可能会随着时间的推移而变得很大，如果不进行清理的话。
 建议删除不必要的软件包并设置清理规则以自动管理软件包注册表的使用情况。
 每个软件包所有者（用户或组织）都可以管理应用于其软件包的清理规则。
 | 设置                         | 描述                                                                                                                                     |
 | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
 | 启用                         | 打开或关闭清理规则。                                                                                                                     |
 | 类型                         | 每个规则管理特定的软件包类型。                                                                                                           |
 | 将模式应用于完整的软件包名称 | 如果启用，则应用以下模式到完整的软件包名称（`package/version`），否则只使用版本号（`version`）。                                         |
 | 保留最近的版本数             | 对于每个软件包要始终保留的版本数量。                                                                                                     |
 | 保留与以下模式匹配的版本     | 确定要保留哪些版本的正则表达式模式。空模式表示不保留任何版本，而 `.+` 表示保留所有版本。即使未配置，容器注册表也始终保留 `latest` 版本。 |
 | 删除早于多少天的版本         | 仅删除早于所选天数的版本。                                                                                                               |
 | 删除与以下模式匹配的版本     | 确定要删除哪些版本的正则表达式模式。空模式或 `.+` 表示如果没有其他设置指定，则删除所有软件包。                                           |
 每个清理规则都可以显示受影响的软件包的预览。
 这可以用来检查清理规则是否正确配置。
 ### 正则表达式示例
 正则表达式模式会自动使用 `\A` 和 `\z` 锚点进行包围。
 不要在正则表达式模式中包含任何 `\A`、`\z`、`^` 或 `$` 标记，因为它们不是必要的。
 模式是不区分大小写的，与 Gitea 中的软件包注册表的行为相匹配。
 | Pattern                      | Description                                                                                                   |
 | ---------------------------- | ------------------------------------------------------------------------------------------------------------- |
 | `.*`                         | 匹配任何可能的版本。                                                                                          |
 | `v.+`                        | 匹配以 `v` 开头的版本。                                                                                       |
 | `release`                    | 仅匹配版本号为 `release`。                                                                                    |
 | `release.*`                  | 匹配以 `release` 命名或以 `release` 开头的版本。                                                              |
 | `.+-temp-.+`                 | 匹配包含 `-temp-` 的版本。                                                                                    |
 | `v.+\|release`               | 匹配以 `v` 开头的版本或版本号为 `release`。                                                                   |
 | `package/v.+\|other/release` | 匹配以 `v` 开头的 package 的版本或 `other` 的版本号为 `release`。需要启用*将模式应用于完整的软件包名称*设置。 |
 ### 清理规则的工作原理
 清理规则是清理任务的一部分，定期运行。
 清理规则：
 1. 收集所有属于所有者注册表的特定软件包类型的软件包。
 2. 对于每个软件包，收集所有版本。
 3. 根据 *保留最近的版本数* 的值，从列表中排除版本。
 4. 根据 *保留与以下模式匹配的版本* 的值，从列表中排除任何版本。
 5. 根据 *删除早于多少天的版本* 的值，从列表中排除比这个值更近的版本。
 6. 根据 *删除与以下模式匹配的版本* 的值，从列表中排除任何不匹配的版本。
 7. 删除剩余的版本。
--- a/docs/content/doc/packages/swift.zh-cn.md
+++ b/docs/content/doc/packages/swift.zh-cn.md
@ -0,0 +1,94 @@
 ---
 date: "2023-01-10T00:00:00+00:00"
 title: "Swift 软件包注册表"
 slug: "swift"
 weight: 95
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Swift"
    weight: 95
    identifier: "swift"
 ---
 # Swift 软件包注册表
 为您的用户或组织发布 [Swift](https://www.swift.org/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 Swift 软件包注册表，您需要使用 [swift](https://www.swift.org/getting-started/) 消费软件包，并使用 HTTP 客户端（如 `curl`）发布软件包。
 ## 配置软件包注册表
 要注册软件包注册表并提供凭据，请执行以下命令：
 ```shell
 swift package-registry set https://gitea.example.com/api/packages/{owner}/swift -login {username} -password {password}
 ```
 | 占位符     | 描述                                                                                                                                           |
 | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
 | `owner`    | 软件包的所有者。                                                                                                                               |
 | `username` | 您的 Gitea 用户名。                                                                                                                            |
 | `password` | 您的 Gitea 密码。如果您使用两步验证或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})代替密码。 |
 登录是可选的，只有在软件包注册表是私有的情况下才需要。
 ## 发布软件包
 首先，您需要打包软件包的内容：
 ```shell
 swift package archive-source
 ```
 要发布软件包，请执行一个带有软件包内容的 HTTP `PUT` 请求，将内容放在请求正文中。
 ```shell --user your_username:your_password_or_token \
 curl -X PUT --user {username}:{password} \
 	 -H "Accept: application/vnd.swift.registry.v1+json" \
 	 -F source-archive=@/path/to/package.zip \
 	 -F metadata={metadata} \
 	 https://gitea.example.com/api/packages/{owner}/swift/{scope}/{name}/{version}
 ```
 | 占位符     | 描述                                                                                                                                           |
 | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
 | `username` | 您的 Gitea 用户名。                                                                                                                            |
 | `password` | 您的 Gitea 密码。如果您使用两步验证或 OAuth，请使用[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})代替密码。 |
 | `owner`    | 软件包的所有者。                                                                                                                               |
 | `scope`    | 软件包的作用域。                                                                                                                               |
 | `name`     | 软件包的名称。                                                                                                                                 |
 | `version`  | 软件包的版本。                                                                                                                                 |
 | `metadata` | （可选）软件包的元数据。以 JSON 编码的子集，格式参考 https://schema.org/SoftwareSourceCode                                                     |
 如果已经存在相同名称和版本的软件包，则无法发布软件包。您必须首先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表安装 Swift 软件包，请将其添加到 `Package.swift` 文件的依赖项列表中：
 ```
 dependencies: [
 	.package(id: "{scope}.{name}", from:"{version}")
 ]
 ```
 | 参数      | 描述           |
 | --------- | -------------- |
 | `scope`   | 软件包的作用域 |
 | `name`    | 软件包的名称   |
 | `version` | 软件包的版本   |
 之后，执行以下命令来安装它：
 ```shell
 swift package resolve
 ```
--- a/docs/content/doc/packages/vagrant.zh-cn.md
+++ b/docs/content/doc/packages/vagrant.zh-cn.md
@ -0,0 +1,79 @@
 ---
 date: "2022-08-23T00:00:00+00:00"
 title: "Vagrant 软件包注册表"
 slug: "vagrant"
 weight: 120
 draft: false
 toc: false
 menu:
  sidebar:
    parent: "packages"
    name: "Vagrant"
    weight: 120
    identifier: "vagrant"
 ---
 # Vagrant 软件包注册表
 为您的用户或组织发布 [Vagrant](https://www.vagrantup.com/) 软件包。
 **目录**
 {{< toc >}}
 ## 要求
 要使用 Vagrant 软件包注册表，您需要安装 [Vagrant](https://www.vagrantup.com/downloads) 并使用类似于 `curl` 的工具进行 HTTP 请求。
 ## 发布软件包
 通过执行 HTTP PUT 请求将 Vagrant box 发布到注册表：
 ```
 PUT https://gitea.example.com/api/packages/{owner}/vagrant/{package_name}/{package_version}/{provider}.box
 ```
 | 参数              | 描述                                                               |
 | ----------------- | ------------------------------------------------------------------ |
 | `owner`           | 软件包的所有者                                                     |
 | `package_name`    | 软件包的名称                                                       |
 | `package_version` | 软件包的版本，兼容 semver 格式                                     |
 | `provider`        | [支持的提供程序名称](https://www.vagrantup.com/docs/providers)之一 |
 上传 Hyper-V box 的示例：
 ```shell
 curl --user your_username:your_password_or_token \
     --upload-file path/to/your/vagrant.box \
     https://gitea.example.com/api/packages/testuser/vagrant/test_system/1.0.0/hyperv.box
 ```
 如果已经存在相同名称、版本和提供程序的软件包，则无法发布软件包。您必须首先删除现有的软件包。
 ## 安装软件包
 要从软件包注册表安装软件包，请执行以下命令：
 ```shell
 vagrant box add "https://gitea.example.com/api/packages/{owner}/vagrant/{package_name}"
 ```
 | 参数           | 描述            |
 | -------------- | --------------- |
 | `owner`        | 软件包的所有者. |
 | `package_name` | 软件包的名称    |
 例如：
 ```shell
 vagrant box add "https://gitea.example.com/api/packages/testuser/vagrant/test_system"
 ```
 这将安装软件包的最新版本。要添加特定版本，请使用` --box-version` 参数。
 如果注册表是私有的，您可以将您的[个人访问令牌]({{< relref "doc/development/api-usage.zh-cn.md#通过-api-认证" >}})传递给 `VAGRANT_CLOUD_TOKEN` 环境变量。
 ## 支持的命令
 ```
 vagrant box add
 ```
Author	SHA1	Message	Date
sillyguodong	95bf09fca0	Add chinese documentations for Packages (#24914 ) (#25016 ) backport: #24914	2023-05-31 15:55:01 +08:00
sillyguodong	3b5cc02345	Add chinese documentations for installation (#24904 ) (#25015 ) backport #24904	2023-05-31 14:17:19 +08:00
HesterG	37b73b3337	Add Chinese docs for help, contribution and development (#24925 ) (#25011 ) Backport #24925, partially backport #24934 (`docs/content/doc/help/faq.zh-cn.md` file) Part of backport has already done by #24942 Also backport #24881 to avoid "deadlock" --------- Co-authored-by: Zettat123 <zettat123@gmail.com>	2023-05-31 14:12:37 +08:00