1mod create_answer;
2mod create_comment;
3mod create_question;
4mod update_answer;
5mod update_comment;
6mod update_question;
7mod vote;
8
9use chrono::{DateTime, Utc};
10use serde::Serialize;
11use uuid::Uuid;
12
13use gitdot_core::dto::{AnswerResponse, AuthorResponse, CommentResponse, QuestionResponse};
14
15pub use create_answer::CreateAnswerServerRequest;
16pub use create_comment::CreateCommentServerRequest;
17pub use create_question::CreateQuestionServerRequest;
18pub use update_answer::UpdateAnswerServerRequest;
19pub use update_comment::UpdateCommentServerRequest;
20pub use update_question::UpdateQuestionServerRequest;
21pub use vote::{VoteServerRequest, VoteServerResponse};
22
23#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
24pub struct QuestionServerResponse {
25    pub id: Uuid,
26    pub number: i32,
27    pub author_id: Uuid,
28    pub repository_id: Uuid,
29    pub title: String,
30    pub body: String,
31    pub upvote: i32,
32    pub impression: i32,
33    pub created_at: DateTime<Utc>,
34    pub updated_at: DateTime<Utc>,
35    pub user_vote: Option<i16>,
36    pub author: Option<AuthorServerResponse>,
37    pub comments: Vec<CommentServerResponse>,
38    pub answers: Vec<AnswerServerResponse>,
39}
40
41impl From<QuestionResponse> for QuestionServerResponse {
42    fn from(response: QuestionResponse) -> Self {
43        Self {
44            id: response.id,
45            number: response.number,
46            author_id: response.author_id,
47            repository_id: response.repository_id,
48            title: response.title,
49            body: response.body,
50            upvote: response.upvote,
51            impression: response.impression,
52            created_at: response.created_at,
53            updated_at: response.updated_at,
54            user_vote: response.user_vote,
55            author: response.author.map(AuthorServerResponse::from),
56            comments: response
57                .comments
58                .into_iter()
59                .map(CommentServerResponse::from)
60                .collect(),
61            answers: response
62                .answers
63                .into_iter()
64                .map(AnswerServerResponse::from)
65                .collect(),
66        }
67    }
68}
69
70#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
71pub struct AnswerServerResponse {
72    pub id: Uuid,
73    pub question_id: Uuid,
74    pub author_id: Uuid,
75    pub body: String,
76    pub upvote: i32,
77    pub created_at: DateTime<Utc>,
78    pub updated_at: DateTime<Utc>,
79    pub user_vote: Option<i16>,
80    pub author: Option<AuthorServerResponse>,
81    pub comments: Vec<CommentServerResponse>,
82}
83
84impl From<AnswerResponse> for AnswerServerResponse {
85    fn from(response: AnswerResponse) -> Self {
86        Self {
87            id: response.id,
88            question_id: response.question_id,
89            author_id: response.author_id,
90            body: response.body,
91            upvote: response.upvote,
92            created_at: response.created_at,
93            updated_at: response.updated_at,
94            user_vote: response.user_vote,
95            author: response.author.map(AuthorServerResponse::from),
96            comments: response
97                .comments
98                .into_iter()
99                .map(CommentServerResponse::from)
100                .collect(),
101        }
102    }
103}
104
105#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
106pub struct CommentServerResponse {
107    pub id: Uuid,
108    pub parent_id: Uuid,
109    pub author_id: Uuid,
110    pub body: String,
111    pub upvote: i32,
112    pub created_at: DateTime<Utc>,
113    pub updated_at: DateTime<Utc>,
114    pub user_vote: Option<i16>,
115    pub author: Option<AuthorServerResponse>,
116}
117
118impl From<CommentResponse> for CommentServerResponse {
119    fn from(response: CommentResponse) -> Self {
120        Self {
121            id: response.id,
122            parent_id: response.parent_id,
123            author_id: response.author_id,
124            body: response.body,
125            upvote: response.upvote,
126            created_at: response.created_at,
127            updated_at: response.updated_at,
128            user_vote: response.user_vote,
129            author: response.author.map(AuthorServerResponse::from),
130        }
131    }
132}
133
134#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
135pub struct AuthorServerResponse {
136    pub id: Uuid,
137    pub name: String,
138}
139
140impl From<AuthorResponse> for AuthorServerResponse {
141    fn from(response: AuthorResponse) -> Self {
142        Self {
143            id: response.id,
144            name: response.name,
145        }
146    }
147}
148