Centralize Gitea domain workflows

crates/gitea/src/domain.rs

@@ -0,0 +1,235 @@
+use std::collections::HashMap;
+
+use crate::models;
+
+pub const DEFAULT_PAGE_SIZE: i32 = 30;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RepositoryId {
+    pub owner: String,
+    pub repository: String,
+}
+
+impl RepositoryId {
+    pub fn new(owner: impl Into<String>, repository: impl Into<String>) -> crate::Result<Self> {
+        let result = Self {
+            owner: owner.into(),
+            repository: repository.into(),
+        };
+        if result.owner.is_empty()
+            || result.repository.is_empty()
+            || result.owner.contains('/')
+            || result.repository.contains('/')
+        {
+            return Err(crate::Error::InvalidInput(
+                "repository must be OWNER/REPOSITORY".into(),
+            ));
+        }
+        Ok(result)
+    }
+
+    pub fn parse(value: &str) -> crate::Result<Self> {
+        let (owner, repository) = value.split_once('/').ok_or_else(|| {
+            crate::Error::InvalidInput("repository must be OWNER/REPOSITORY".into())
+        })?;
+        Self::new(owner, repository)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Page<T> {
+    pub items: Vec<T>,
+    pub has_more: bool,
+}
+
+impl<T> Page<T> {
+    pub fn from_items(items: Vec<T>, limit: i32) -> Self {
+        Self {
+            has_more: limit > 0 && items.len() == limit as usize,
+            items,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct IssueQuery {
+    pub state: String,
+    pub labels: Option<String>,
+    pub keyword: Option<String>,
+    pub kind: String,
+    pub milestones: Option<String>,
+    pub from: Option<String>,
+    pub until: Option<String>,
+    pub author: Option<String>,
+    pub assignee: Option<String>,
+    pub mentions: Option<String>,
+    pub page: i32,
+    pub limit: i32,
+}
+
+impl Default for IssueQuery {
+    fn default() -> Self {
+        Self {
+            state: "open".into(),
+            labels: None,
+            keyword: None,
+            kind: "issues".into(),
+            milestones: None,
+            from: None,
+            until: None,
+            author: None,
+            assignee: None,
+            mentions: None,
+            page: 1,
+            limit: DEFAULT_PAGE_SIZE,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct CreateIssue {
+    pub option: models::CreateIssueOption,
+    pub label_names: Vec<String>,
+    pub milestone_name: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct EditIssue {
+    pub option: models::EditIssueOption,
+    pub replace_labels: Option<Vec<i64>>,
+    pub add_labels: Vec<String>,
+    pub remove_labels: Vec<String>,
+    pub add_assignees: Vec<String>,
+    pub milestone_name: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct IssueDraft {
+    pub title: String,
+    pub body: String,
+    pub label_ids: Vec<i64>,
+    pub milestone_id: Option<i64>,
+    pub due_date: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct IssueDetails {
+    pub issue: models::Issue,
+    pub comments: Vec<models::Comment>,
+    pub viewer_id: Option<i64>,
+    pub has_more: bool,
+}
+
+#[derive(Clone, Debug)]
+pub struct IssueEditorData {
+    pub issue: Option<models::Issue>,
+    pub labels: Vec<models::Label>,
+    pub milestones: Vec<models::Milestone>,
+}
+
+#[derive(Clone, Debug)]
+pub struct MilestoneDraft {
+    pub title: String,
+    pub description: String,
+    pub due_on: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct MilestoneDetails {
+    pub milestone: models::Milestone,
+    pub issues: Vec<models::Issue>,
+    pub pulls: Vec<models::Issue>,
+    pub has_more: bool,
+}
+
+#[derive(Clone, Debug)]
+pub struct PullDetails {
+    pub pull: models::PullRequest,
+    pub comments: Vec<models::Comment>,
+    pub files: Vec<models::ChangedFile>,
+    pub has_more: bool,
+}
+
+#[derive(Clone, Debug)]
+pub struct HistoryCommit {
+    pub commit: models::Commit,
+    pub top_lanes: Vec<usize>,
+    pub bottom_lanes: Vec<usize>,
+    pub node_lane: Option<usize>,
+    pub connections: Vec<usize>,
+    pub refs: Vec<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct HomeData {
+    pub activities: Vec<models::Activity>,
+    pub heatmap: Vec<models::UserHeatmapData>,
+    pub has_more: bool,
+}
+
+pub type PullRefs = HashMap<String, Vec<String>>;
+
+pub fn api_date(timestamp: i64) -> String {
+    let (year, month, day) = civil_from_days(timestamp.div_euclid(86_400));
+    format!("{year:04}-{month:02}-{day:02}T00:00:00Z")
+}
+
+pub fn parse_api_date(value: &str) -> Option<i64> {
+    let date = value.get(..10)?;
+    let mut parts = date.split('-');
+    let year = parts.next()?.parse().ok()?;
+    let month = parts.next()?.parse().ok()?;
+    let day = parts.next()?.parse().ok()?;
+    if parts.next().is_some() || !(1..=12).contains(&month) || !(1..=31).contains(&day) {
+        return None;
+    }
+    let days = days_from_civil(year, month, day);
+    (civil_from_days(days) == (year, month, day)).then_some(days * 86_400)
+}
+
+fn civil_from_days(days: i64) -> (i64, i64, i64) {
+    let days = days + 719_468;
+    let era = days.div_euclid(146_097);
+    let day_of_era = days - era * 146_097;
+    let year_of_era =
+        (day_of_era - day_of_era / 1_460 + day_of_era / 36_524 - day_of_era / 146_096) / 365;
+    let mut year = year_of_era + era * 400;
+    let day_of_year = day_of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
+    let month_prime = (5 * day_of_year + 2) / 153;
+    let day = day_of_year - (153 * month_prime + 2) / 5 + 1;
+    let month = month_prime + if month_prime < 10 { 3 } else { -9 };
+    year += i64::from(month <= 2);
+    (year, month, day)
+}
+
+fn days_from_civil(mut year: i64, month: i64, day: i64) -> i64 {
+    year -= i64::from(month <= 2);
+    let era = year.div_euclid(400);
+    let year_of_era = year - era * 400;
+    let month_prime = month + if month > 2 { -3 } else { 9 };
+    let day_of_year = (153 * month_prime + 2) / 5 + day - 1;
+    let day_of_era = year_of_era * 365 + year_of_era / 4 - year_of_era / 100 + day_of_year;
+    era * 146_097 + day_of_era - 719_468
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn validates_repositories_pages_and_dates() {
+        assert_eq!(
+            RepositoryId::parse("alice/project").unwrap(),
+            RepositoryId {
+                owner: "alice".into(),
+                repository: "project".into(),
+            }
+        );
+        assert!(RepositoryId::parse("project").is_err());
+        assert!(Page::from_items(vec![(); 30], 30).has_more);
+        assert!(!Page::from_items(vec![(); 29], 30).has_more);
+        let leap_day = parse_api_date("2024-02-29T12:34:56Z").unwrap();
+        assert_eq!(api_date(leap_day), "2024-02-29T00:00:00Z");
+        assert_eq!(parse_api_date("2023-02-29T00:00:00Z"), None);
+    }
+}