signer-daemon 0.2.1

Signer daemon 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

use anyhow::bail;
use serde::{Deserialize, Serialize};

use super::deltaobject::DeltaField;
use crate::model::viewobject::{ChatVO, MessageContent, MessageVO};

#[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) -> anyhow::Result<Self> {
    if from.id != to.id {
      bail!("message id not equal")
    }
    if from.chat != to.chat {
      bail!("message chat key not equal")
    }
    if from.user_key != to.user_key {
      bail!("message user key not equal")
    }

    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),
    }
  }
}