path: root/server/api/src/api_model.rs

use serde::{Deserialize, Serialize};
use utoipa::ToSchema;

#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub enum ReviewState {
    Draft,
    Open,
    Dropped,
    Closed,
}

impl TryFrom<u8> for ReviewState {
    type Error = &'static str;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(ReviewState::Draft),
            1 => Ok(ReviewState::Open),
            2 => Ok(ReviewState::Dropped),
            3 => Ok(ReviewState::Closed),
            _ => Err("Invalid review state"),
        }
    }
}

#[derive(Copy, Clone, Deserialize, Serialize, ToSchema)]
pub enum Rewrite {
    Disabled,
    History,
    Rebase,
}

impl TryFrom<u8> for Rewrite {
    type Error = &'static str;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Rewrite::Disabled),
            1 => Ok(Rewrite::History),
            2 => Ok(Rewrite::Rebase),
            _ => Err("Invalid review state"),
        }
    }
}

#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub enum UserReviewRole {
    Reviewer,
    Watcher,
    None,
}

impl TryFrom<u8> for UserReviewRole {
    type Error = &'static str;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(UserReviewRole::None),
            1 => Ok(UserReviewRole::Reviewer),
            2 => Ok(UserReviewRole::Watcher),
            _ => Err("Invalid role"),
        }
    }
}

impl From<UserReviewRole> for u8 {
    fn from(value: UserReviewRole) -> u8 {
        match value {
            UserReviewRole::None => 0,
            UserReviewRole::Reviewer => 1,
            UserReviewRole::Watcher => 2,
        }
    }
}

#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub enum TranslationState {
    Unreviewed,
    Unchanged,
    Approved,
    Revert,
    Fix,
}

impl TryFrom<u8> for TranslationState {
    type Error = &'static str;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(TranslationState::Unreviewed),
            1 => Ok(TranslationState::Unchanged),
            2 => Ok(TranslationState::Approved),
            3 => Ok(TranslationState::Revert),
            4 => Ok(TranslationState::Fix),
            _ => Err("Invalid translation state"),
        }
    }
}

impl From<TranslationState> for u8 {
    fn from(value: TranslationState) -> u8 {
        match value {
            TranslationState::Unreviewed => 0,
            TranslationState::Unchanged => 1,
            TranslationState::Approved => 2,
            TranslationState::Revert => 3,
            TranslationState::Fix => 4,
        }
    }
}

#[derive(Debug, Deserialize, Serialize, PartialEq, ToSchema)]
pub struct User {
    #[schema(example = "jsmith")]
    pub id: String,
    #[schema(example = "John Smith")]
    pub name: String,
    #[schema(example = true)]
    pub active: bool,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct Users {
    #[schema(example = 0u32)]
    pub offset: u32,
    #[schema(example = 10u32)]
    pub limit: u32,
    #[schema(example = 42u32)]
    pub total_count: u32,
    #[schema(example = true)]
    pub more: bool,
    pub users: Vec<User>,
}

#[derive(Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub struct ReviewUserEntry {
    pub user: User,
    #[schema(example = UserReviewRole::Reviewer)]
    pub role: UserReviewRole,
}

#[derive(Serialize, ToSchema)]
pub struct Review {
    #[schema(example = 1000u64)]
    pub id: u64,
    #[schema(example = "FAKE-512: Add more features")]
    pub title: String,
    #[schema(example = "We're adding more features because features are what we want.")]
    pub description: String,
    pub owner: User,
    pub users: Vec<ReviewUserEntry>,
    #[schema(example = ReviewState::Open)]
    pub state: ReviewState,
    #[schema(example = 37.5)]
    pub progress: f32,
    #[schema(example = "r/user/TASK-123456")]
    pub branch: String,
    #[schema(example = false)]
    pub archived: bool,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct ReviewEntry {
    #[schema(example = 1000u64)]
    pub id: u64,
    #[schema(example = "FAKE-512: Add more features")]
    pub title: String,
    pub owner: User,
    #[schema(example = ReviewState::Open)]
    pub state: ReviewState,
    #[schema(example = 37.5)]
    pub progress: f32,
    #[schema(example = "r/user/TASK-123456")]
    pub branch: String,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct Reviews {
    #[schema(example = 0u32)]
    pub offset: u32,
    #[schema(example = 10u32)]
    pub limit: u32,
    #[schema(example = 42u32)]
    pub total_count: u32,
    #[schema(example = true)]
    pub more: bool,
    pub reviews: Vec<ReviewEntry>,
}

#[derive(Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub struct ProjectUserEntry {
    pub user: User,
    #[schema(example = UserReviewRole::Reviewer)]
    pub default_role: UserReviewRole,
    #[schema(example = false)]
    pub maintainer: bool,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct ProjectUserEntryData {
    #[schema(example = UserReviewRole::Reviewer)]
    pub default_role: Option<UserReviewRole>,
    #[schema(example = false)]
    pub maintainer: Option<bool>,
}

#[derive(Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub struct Project {
    #[schema(example = "fake")]
    pub id: String,
    #[schema(example = "FAKE: Features All Kids Erase")]
    pub title: String,
    #[schema(example = "Example project")]
    pub description: String,
    #[schema(example = "ssh://git.example.org/srv/git/")]
    pub remote: String,
    #[schema(example = "b3BlbNNz...AQIDBA==")]
    pub remote_key_abbrev: String,
    #[schema(example = "main")]
    pub main_branch: String,
    pub users: Vec<ProjectUserEntry>,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct ProjectData<'r> {
    #[schema(example = "FAKE: Features All Kids Erase")]
    pub title: Option<&'r str>,
    #[schema(example = "Example project")]
    pub description: Option<&'r str>,
    #[schema(example = "ssh://git.example.org/srv/git/")]
    pub remote: Option<&'r str>,
    #[schema(example = "b3BlbNNz...AQIDBA==")]
    pub remote_key: Option<String>,
    #[schema(example = "main")]
    pub main_branch: Option<&'r str>,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct ProjectEntry {
    #[schema(example = "fake")]
    pub id: String,
    #[schema(example = "FAKE: Features All Kids Erase")]
    pub title: String,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct Projects {
    #[schema(example = 0u32)]
    pub offset: u32,
    #[schema(example = 10u32)]
    pub limit: u32,
    #[schema(example = 1u32)]
    pub total_count: u32,
    #[schema(example = false)]
    pub more: bool,
    pub projects: Vec<ProjectEntry>,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct StatusResponse {
    pub ok: bool,
    #[serde(
        skip_serializing_if = "Option::is_none",
        // &'static str is problematic for serde, only used in tests anyway.
        skip_deserializing,
    )]
    pub error: Option<&'static str>,
}

#[derive(Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub struct UserKey {
    #[schema(example = 1u64)]
    pub id: u64,
    #[schema(example = "ssh-rsa")]
    pub kind: String,
    #[schema(example = "AAAAfoobar==")]
    pub data: String,
    #[schema(example = "user@host 1970-01-01")]
    pub comment: String,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct UserKeyData<'r> {
    #[schema(example = "ssh-rsa")]
    pub kind: &'r str,
    #[schema(example = "AAAAfoobar==")]
    pub data: &'r str,
    #[schema(example = "user@host 1970-01-01")]
    pub comment: Option<&'r str>,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct UserKeys {
    #[schema(example = 0u32)]
    pub offset: u32,
    #[schema(example = 10u32)]
    pub limit: u32,
    #[schema(example = 2u32)]
    pub total_count: u32,
    #[schema(example = false)]
    pub more: bool,
    pub keys: Vec<UserKey>,
}

#[derive(Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub struct LocalizationString {
    #[schema(example = "IDS_GENERIC_WELCOME")]
    pub id: String,
    #[schema(example = "strings/strings.grd")]
    pub file: String,
    #[schema(example = "Generic greating")]
    pub description: String,
    #[schema(example = "This should be a positive greating")]
    pub meaning: String,
    #[schema(example = "Hello!")]
    pub source: String,
    pub placeholders: Vec<LocalizationPlaceholder>,
    pub placeholder_offset: Vec<usize>,
    pub translations: Vec<TranslationString>,
}

#[derive(Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub struct LocalizationPlaceholder {
    #[schema(example = "NAME")]
    pub id: String,
    #[schema(example = "%1$d")]
    pub content: String,
    #[schema(example = "42")]
    pub example: String,
}

#[derive(Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub struct TranslationString {
    #[schema(example = "sv")]
    pub language: String,
    #[schema(example = "Hej!")]
    pub translation: String,
    pub placeholder_offset: Vec<usize>,
    pub state: TranslationState,
    pub comment: String,
    pub reviewer: Option<User>,
}

#[derive(Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub struct TranslationReview {
    #[schema(example = 1u64)]
    pub id: u64,
    #[schema(example = "FAKE-512: Update translations")]
    pub title: String,
    #[schema(example = "New translations")]
    pub description: String,
    pub owner: User,
    pub users: Vec<ReviewUserEntry>,
    #[schema(example = ReviewState::Open)]
    pub state: ReviewState,
    #[schema(example = 37.5)]
    pub progress: f32,
    #[schema(example = false)]
    pub archived: bool,
    #[schema(example = "d7c502b9c6b833060576a0c4da0287933d603011")]
    pub base: String,
    #[schema(example = "2cecdec660a30bf3964cee645d9cee03640ef8dc")]
    pub head: String,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct TranslationReviewData<'r> {
    #[schema(example = "FAKE-512: Update translations")]
    pub title: String,
    #[schema(example = "New translations")]
    pub description: String,
    #[schema(example = "d7c502b9c6b833060576a0c4da0287933d603011")]
    pub base: Option<&'r str>,
}

#[derive(Debug, Deserialize, PartialEq, Serialize, ToSchema)]
pub struct TranslationReviewEntry {
    #[schema(example = 1u64)]
    pub id: u64,
    #[schema(example = "FAKE-512: Update translations")]
    pub title: String,
    pub owner: User,
    #[schema(example = ReviewState::Open)]
    pub state: ReviewState,
    #[schema(example = 37.5)]
    pub progress: f32,
    #[schema(example = "d7c502b9c6b833060576a0c4da0287933d603011")]
    pub base: String,
    #[schema(example = "2cecdec660a30bf3964cee645d9cee03640ef8dc")]
    pub head: String,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct TranslationReviews {
    #[schema(example = 0u32)]
    pub offset: u32,
    #[schema(example = 10u32)]
    pub limit: u32,
    #[schema(example = 42u32)]
    pub total_count: u32,
    #[schema(example = true)]
    pub more: bool,
    pub reviews: Vec<TranslationReviewEntry>,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct LocalizationStrings {
    #[schema(example = 0u32)]
    pub offset: u32,
    #[schema(example = 10u32)]
    pub limit: u32,
    #[schema(example = 42u32)]
    pub total_count: u32,
    #[schema(example = true)]
    pub more: bool,
    pub strings: Vec<LocalizationString>,
}