atri_bot 0.5.3

A simple bot
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::error::{AtriError, AtriResult};
use crate::message::image::Image;
use crate::message::meta::MetaMessage;
use crate::message::MessageChain;
use crate::Client;
use ricq::structs::{FriendInfo, MessageReceipt};
use std::sync::Arc;
use tracing::error;

#[derive(Clone)]
pub struct Friend(Arc<imp::Friend>);

impl Friend {
    pub fn id(&self) -> i64 {
        self.0.info.uin
    }

    pub fn nickname(&self) -> &str {
        &self.0.info.nick
    }

    pub fn remark(&self) -> &str {
        &self.0.info.remark
    }

    pub fn client(&self) -> &Client {
        &self.0.client
    }

    pub async fn delete(&self) -> bool {
        let result = self
            .client()
            .request_client()
            .delete_friend(self.id())
            .await;

        if let Err(e) = result {
            error!(
                "尝试删除好友 {}({}) 时失败: {:?}",
                self.nickname(),
                self.id(),
                e
            );
            return false;
        }

        let map = self.client().remove_friend_cache(self.id());

        map.is_some()
    }

    pub async fn send_message(&self, chain: MessageChain) -> AtriResult<MessageReceipt> {
        let result = self
            .client()
            .request_client()
            .send_friend_message(self.id(), chain.into())
            .await;

        if let Err(ref e) = result {
            error!(
                "{}发送消息失败, 目标好友: {}({}), {:?}",
                self.client(),
                self.nickname(),
                self.id(),
                e
            );
        }

        result.map_err(AtriError::from)
    }

    pub async fn upload_image(&self, image: Vec<u8>) -> AtriResult<Image> {
        let f = self
            .client()
            .request_client()
            .upload_friend_image(self.id(), image)
            .await?;

        Ok(Image::Friend(f))
    }

    pub async fn recall_message<M: MetaMessage>(&self, msg: &M) -> AtriResult<()> {
        let meta = msg.metadata();
        self.client()
            .request_client()
            .recall_friend_message(
                self.id(),
                meta.time as i64,
                meta.seqs.clone(),
                meta.rands.clone(),
            )
            .await
            .map_err(AtriError::from)
    }

    pub(crate) fn from(client: Client, info: FriendInfo) -> Self {
        let f = imp::Friend { client, info };

        Self(Arc::new(f))
    }
}

mod imp {
    use crate::Client;
    use ricq::structs::FriendInfo;

    pub struct Friend {
        pub client: Client,
        pub info: FriendInfo,
    }
}