signer-crdt 0.4.1

Signer CRDT (Conflict-free Replicated Data Type) package.
Documentation 
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use serde::{Deserialize, Serialize};

use super::deltaobject::DeltaField;
use crate::{view::{ChatVO, MessageContent, MessageVO}, DeltaError};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MessageDO {
    pub id: String,
    pub chat: ChatVO,
    pub user_key: String,
    pub parent_id: DeltaField<Option<String>>,
    pub parent_user_key: DeltaField<Option<String>>,
    pub content: DeltaField<MessageContent>,
    pub content_type: DeltaField<String>,
    pub receiver_keys: DeltaField<Vec<String>>,
    pub create_time: DeltaField<i64>,
}

impl MessageDO {
    pub fn new(from: &MessageVO, to: &MessageVO) -> Result<Self, DeltaError> {
        if from.id != to.id {
            return Err(DeltaError::InvalidParamsError(
                "message id not equal".to_string(),
            ));
        }
        if from.chat != to.chat {
            return Err(DeltaError::InvalidParamsError(
                "message chat key not equal".to_string(),
            ));
        }
        if from.user_key != to.user_key {
            return Err(DeltaError::InvalidParamsError(
                "message user key not equal".to_string(),
            ));
        }

        Ok(Self {
            id: from.id.clone(),
            parent_id: DeltaField::new(&from.parent_id, &to.parent_id),
            parent_user_key: DeltaField::new(&from.parent_user_key, &to.parent_user_key),
            content_type: DeltaField::new(&from.content.ty(), &to.content.ty()),
            content: DeltaField::new(&from.content, &to.content),
            receiver_keys: DeltaField::new(&from.receiver_keys, &to.receiver_keys),
            chat: from.chat.clone(),
            user_key: from.user_key.clone(),
            create_time: DeltaField::new(&from.create_time, &to.create_time),
        })
    }

    pub fn has_changed(&self, vo: &MessageVO) -> bool {
        if let DeltaField::Set(val) = &self.parent_id {
            if *val != vo.parent_id {
                return true;
            }
        }
        if let DeltaField::Set(val) = &self.parent_user_key {
            if *val != vo.parent_user_key {
                return true;
            }
        }
        if let DeltaField::Set(val) = &self.content {
            if *val != vo.content {
                return true;
            }
        }
        if let DeltaField::Set(val) = &self.create_time {
            if *val != vo.create_time {
                return true;
            }
        }
        if let DeltaField::Set(val) = &self.receiver_keys {
            if *val != vo.receiver_keys {
                return true;
            }
        }
        false
    }
}

impl From<MessageVO> for MessageDO {
    fn from(value: MessageVO) -> Self {
        Self {
            id: value.id,
            parent_id: DeltaField::Set(value.parent_id),
            parent_user_key: DeltaField::Set(value.parent_user_key),
            content_type: DeltaField::Set(value.content.ty()),
            content: DeltaField::Set(value.content),
            receiver_keys: DeltaField::Set(value.receiver_keys),
            chat: value.chat,
            user_key: value.user_key,
            create_time: DeltaField::Set(value.create_time),
        }
    }
}