1use chrono::{DateTime, Utc};
2use sqlx::{FromRow, Type};
3use uuid::Uuid;
4
5use crate::error::RepositoryError;
6
7#[derive(Debug, Clone, FromRow)]
8pub struct Repository {
9    pub id: Uuid,
10    pub name: String,
11    pub owner_id: Uuid,
12    pub owner_name: String,
13    pub owner_type: RepositoryOwnerType,
14    pub visibility: RepositoryVisibility,
15    pub created_at: DateTime<Utc>,
16}
17
18impl Repository {
19    pub fn is_owned_by_user(&self) -> bool {
20        self.owner_type == RepositoryOwnerType::User
21    }
22
23    pub fn is_owned_by_organization(&self) -> bool {
24        self.owner_type == RepositoryOwnerType::Organization
25    }
26
27    pub fn is_public(&self) -> bool {
28        self.visibility == RepositoryVisibility::Public
29    }
30
31    pub fn is_private(&self) -> bool {
32        self.visibility != RepositoryVisibility::Public
33    }
34}
35
36#[derive(Debug, Clone, PartialEq, Eq, Type)]
37#[sqlx(type_name = "repository_owner_type", rename_all = "lowercase")]
38pub enum RepositoryOwnerType {
39    User,
40    Organization,
41}
42
43impl TryFrom<&str> for RepositoryOwnerType {
44    type Error = RepositoryError;
45
46    fn try_from(owner_type: &str) -> Result<Self, Self::Error> {
47        match owner_type {
48            "user" => Ok(RepositoryOwnerType::User),
49            "organization" => Ok(RepositoryOwnerType::Organization),
50            _ => Err(RepositoryError::InvalidOwnerType(owner_type.to_string())),
51        }
52    }
53}
54
55impl Into<String> for RepositoryOwnerType {
56    fn into(self) -> String {
57        match self {
58            RepositoryOwnerType::User => "user".to_string(),
59            RepositoryOwnerType::Organization => "organization".to_string(),
60        }
61    }
62}
63
64#[derive(Debug, Clone, PartialEq, Eq, Type)]
65#[sqlx(type_name = "repository_visibility", rename_all = "lowercase")]
66pub enum RepositoryVisibility {
67    Public,
68    Private,
69}
70
71impl TryFrom<&str> for RepositoryVisibility {
72    type Error = RepositoryError;
73
74    fn try_from(visibility: &str) -> Result<Self, Self::Error> {
75        match visibility {
76            "public" => Ok(RepositoryVisibility::Public),
77            "private" => Ok(RepositoryVisibility::Private),
78            _ => Err(RepositoryError::InvalidVisibility(visibility.to_string())),
79        }
80    }
81}
82
83impl Into<String> for RepositoryVisibility {
84    fn into(self) -> String {
85        match self {
86            RepositoryVisibility::Public => "public".to_string(),
87            RepositoryVisibility::Private => "private".to_string(),
88        }
89    }
90}
91
92#[derive(Debug, Clone, Copy, PartialEq, Eq)]
93pub enum GitOperation {
94    Read,  // clone, fetch, pull
95    Write, // push
96}
97