1mod create_answer;
2mod create_answer_comment;
3mod create_question;
4mod create_question_comment;
5mod get_question;
6mod list_questions;
7mod update_answer;
8mod update_comment;
9mod update_question;
10mod vote_answer;
11mod vote_comment;
12mod vote_question;
13
14use chrono::{DateTime, Utc};
15use uuid::Uuid;
16
17use crate::model::{Answer, Comment, Question, User, VoteResult};
18
19pub use create_answer::CreateAnswerRequest;
20pub use create_answer_comment::CreateAnswerCommentRequest;
21pub use create_question::CreateQuestionRequest;
22pub use create_question_comment::CreateQuestionCommentRequest;
23pub use get_question::GetQuestionRequest;
24pub use list_questions::ListQuestionsRequest;
25pub use update_answer::UpdateAnswerRequest;
26pub use update_comment::UpdateCommentRequest;
27pub use update_question::UpdateQuestionRequest;
28pub use vote_answer::VoteAnswerRequest;
29pub use vote_comment::VoteCommentRequest;
30pub use vote_question::VoteQuestionRequest;
31
32#[derive(Debug, Clone)]
33pub struct QuestionResponse {
34    pub id: Uuid,
35    pub number: i32,
36    pub author_id: Uuid,
37    pub repository_id: Uuid,
38    pub title: String,
39    pub body: String,
40    pub upvote: i32,
41    pub impression: i32,
42    pub created_at: DateTime<Utc>,
43    pub updated_at: DateTime<Utc>,
44    pub user_vote: Option<i16>,
45    pub author: Option<AuthorResponse>,
46    pub comments: Vec<CommentResponse>,
47    pub answers: Vec<AnswerResponse>,
48}
49
50impl From<Question> for QuestionResponse {
51    fn from(question: Question) -> Self {
52        Self {
53            id: question.id,
54            number: question.number,
55            author_id: question.author_id,
56            repository_id: question.repository_id,
57            title: question.title,
58            body: question.body,
59            upvote: question.upvote,
60            impression: question.impression,
61            created_at: question.created_at,
62            updated_at: question.updated_at,
63            user_vote: question.user_vote,
64            author: question.author.map(AuthorResponse::from),
65            comments: question
66                .comments
67                .unwrap_or_default()
68                .into_iter()
69                .map(CommentResponse::from)
70                .collect(),
71            answers: question
72                .answers
73                .unwrap_or_default()
74                .into_iter()
75                .map(AnswerResponse::from)
76                .collect(),
77        }
78    }
79}
80
81#[derive(Debug, Clone)]
82pub struct AnswerResponse {
83    pub id: Uuid,
84    pub question_id: Uuid,
85    pub author_id: Uuid,
86    pub body: String,
87    pub upvote: i32,
88    pub created_at: DateTime<Utc>,
89    pub updated_at: DateTime<Utc>,
90    pub user_vote: Option<i16>,
91    pub author: Option<AuthorResponse>,
92    pub comments: Vec<CommentResponse>,
93}
94
95impl From<Answer> for AnswerResponse {
96    fn from(answer: Answer) -> Self {
97        Self {
98            id: answer.id,
99            question_id: answer.question_id,
100            author_id: answer.author_id,
101            body: answer.body,
102            upvote: answer.upvote,
103            created_at: answer.created_at,
104            updated_at: answer.updated_at,
105            user_vote: answer.user_vote,
106            author: answer.author.map(AuthorResponse::from),
107            comments: answer
108                .comments
109                .unwrap_or_default()
110                .into_iter()
111                .map(CommentResponse::from)
112                .collect(),
113        }
114    }
115}
116
117#[derive(Debug, Clone)]
118pub struct CommentResponse {
119    pub id: Uuid,
120    pub parent_id: Uuid,
121    pub author_id: Uuid,
122    pub body: String,
123    pub upvote: i32,
124    pub created_at: DateTime<Utc>,
125    pub updated_at: DateTime<Utc>,
126    pub user_vote: Option<i16>,
127    pub author: Option<AuthorResponse>,
128}
129
130impl From<Comment> for CommentResponse {
131    fn from(comment: Comment) -> Self {
132        Self {
133            id: comment.id,
134            parent_id: comment.parent_id,
135            author_id: comment.author_id,
136            body: comment.body,
137            upvote: comment.upvote,
138            created_at: comment.created_at,
139            updated_at: comment.updated_at,
140            user_vote: comment.user_vote,
141            author: comment.author.map(AuthorResponse::from),
142        }
143    }
144}
145
146#[derive(Debug, Clone)]
147pub struct AuthorResponse {
148    pub id: Uuid,
149    pub name: String,
150}
151
152impl From<User> for AuthorResponse {
153    fn from(user: User) -> Self {
154        Self {
155            id: user.id,
156            name: user.name,
157        }
158    }
159}
160
161#[derive(Debug, Clone)]
162pub struct VoteResponse {
163    pub target_id: Uuid,
164    pub score: i32,
165    pub user_vote: Option<i16>,
166}
167
168impl From<VoteResult> for VoteResponse {
169    fn from(vote: VoteResult) -> Self {
170        Self {
171            target_id: vote.target_id,
172            score: vote.new_score,
173            user_vote: vote.user_vote,
174        }
175    }
176}
177