assignmentlib/dto/
answer_group_request.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


use serde::{Deserialize, Serialize};
use uuid::Uuid;


use crate::jsonb::answer::Answer;
use crate::jsonb::answer_group::AnswerGroup;

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct AnswerGroupRequest {
    pub id: Option<Uuid>,
    pub attempt: Option<Uuid>,
    pub question: Uuid,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub answers: Option<Vec<Answer>>,
}

impl AnswerGroupRequest {
    pub fn from_answer(a: &AnswerGroup) -> AnswerGroupRequest {
        AnswerGroupRequest {
            id: a.id,
            attempt: a.attempt,
            question: a.question,
            answers: a.answers.clone(),
        }
    }

    pub fn vec_equal(vec1: &Vec<AnswerGroupRequest>, vec2: &Vec<AnswerGroupRequest>) -> bool {
        let mut eq = true;
        for i in 0..vec1.len() {
            eq &= vec1.get(i).unwrap().equal(vec2.get(i).unwrap());
        }
        eq
    }

    pub fn equal(&self, other: &AnswerGroupRequest) -> bool {
        let mut eq = true;
        eq &= self.id == other.id;
        eq &= self.attempt == other.attempt;
        eq &= self.question == other.question;
        eq &= self.answers == other.answers;
        eq
    }

    pub fn to_answer_group(&self) -> AnswerGroup {
        AnswerGroup {
            id: Option::from(if self.id.is_none() {
                Uuid::new_v4()
            } else {
                self.id.unwrap()
            }),
            attempt: self.attempt,
            question: self.question,
            answers: self.answers.clone(),
        }
    }
}