gitea_sdk/api/repos/
forks.rs

1use build_it::Builder;
2use serde::Serialize;
3
4use crate::{error::Result, model::repos::Repository, Client};
5
6/// Options for forking a repository.
7/// All fields are optional.
8#[derive(Debug, Clone, Serialize, Builder)]
9#[build_it(into)]
10#[serde(default)]
11pub struct CreateForkBuilder {
12    /// The owner of the repository to fork.
13    /// This is the user or organization that owns the repository you want to fork.
14    #[skip]
15    #[serde(skip)]
16    owner: String,
17    /// The name of the repository to fork.
18    #[skip]
19    #[serde(skip)]
20    repo: String,
21    /// The name of the new repository.
22    /// Will be the same as the original if not set.
23    name: Option<String>,
24    /// Organization name, if forking into an organization.
25    organization: Option<String>,
26}
27
28impl CreateForkBuilder {
29    pub fn new(owner: impl ToString, repo: impl ToString) -> Self {
30        Self {
31            owner: owner.to_string(),
32            repo: repo.to_string(),
33            organization: None,
34            name: None,
35        }
36    }
37    /// Send the request to fork the repository.
38    pub async fn send(&self, client: &Client) -> Result<Repository> {
39        let owner = &self.owner;
40        let repo = &self.repo;
41        let req = client
42            .post(format!("repos/{owner}/{repo}/forks"))
43            .json(self)
44            .build()?;
45        let res = client.make_request(req).await?;
46        client.parse_response(res).await
47    }
48}
49
50/// Options for listing a repository's forks.
51/// All fields are optional.
52#[derive(Debug, Clone, Serialize, Builder)]
53#[build_it(into)]
54#[serde(default)]
55pub struct ListForksBuilder {
56    #[skip]
57    #[serde(skip)]
58    /// The owner of the repository to list forks for.
59    owner: String,
60    #[skip]
61    #[serde(skip)]
62    /// The name of the repository to list forks for.
63    repo: String,
64    #[serde(skip_serializing_if = "Option::is_none")]
65    /// Optional page number of the results to fetch (1-based).
66    /// Defaults to 1 if not set.
67    page: Option<i64>,
68    #[serde(skip_serializing_if = "Option::is_none")]
69    /// Optional number of forks to return per page (page-size).
70    /// Defaults to the maximum your instance allows if not set.
71    limit: Option<i64>,
72}
73
74impl ListForksBuilder {
75    pub fn new(owner: impl ToString, repo: impl ToString) -> Self {
76        Self {
77            owner: owner.to_string(),
78            repo: repo.to_string(),
79            page: None,
80            limit: None,
81        }
82    }
83    /// Send the request to list the forks.
84    pub async fn send(&self, client: &Client) -> Result<Vec<Repository>> {
85        let owner = &self.owner;
86        let repo = &self.repo;
87
88        let req = client
89            .get(format!("repos/{owner}/{repo}/forks"))
90            .query(self)
91            .build()?;
92        let res = client.make_request(req).await?;
93        client.parse_response(res).await
94    }
95}